rs namespace

Namespaces

namespace prepo

Typedefs

using break_judge_function_t = bool(*)(const al::SensorMsg*)

Functions

void resetHelpAmiiboState(const al::IUseSceneObjHolder* objHolder)

auto isHelpAmiiboMode(const al::IUseSceneObjHolder* objHolder) -> bool

auto tryCreateEnemyCap(al::LiveActor* actor, const al::ActorInitInfo& info) -> EnemyCap*

auto tryCreateEnemyCap(al::LiveActor* actor, const al::ActorInitInfo& info, const char* archiveName) -> EnemyCap*

auto tryCreateEnemyCapSuffix(al::LiveActor* actor, const al::ActorInitInfo& info, const char* archiveName, const char* suffix) -> EnemyCap*

auto tryStartEnemyCapBlowDown(EnemyCap* cap, const al::HitSensor* sensor) -> bool

auto tryStartEnemyCapBlowDown(EnemyCap* cap) -> bool

auto tryAppearEnemyCap(EnemyCap* cap) -> bool

auto isOnEnemyCap(EnemyCap* cap) -> bool

auto createCoinCollectHolder(const al::IUseSceneObjHolder* objHolder) -> CoinCollectHolder*

auto createCoinCollectWatcher(const al::IUseSceneObjHolder* objHolder) -> CoinCollectWatcher*

void setKidsModeLayoutDisable(const al::IUseSceneObjHolder* user)

void setKidsModeLayoutEnable(const al::IUseSceneObjHolder* user)

auto isKidsModeLayoutDisable(const al::IUseSceneObjHolder* user) -> bool

void calcTransOnMap(sead::Vector2f*, const sead::Vector3f&, const sead::Matrix44f&, const sead::Vector2f&, f32, f32)

auto tryCalcMapNorthDir(sead::Vector3f*, const al::IUseSceneObjHolder*) -> bool

auto getMapViewProjMtx(const al::IUseSceneObjHolder*) -> const sead::Matrix44f&

auto getMapProjMtx(const al::IUseSceneObjHolder*) -> const sead::Matrix44f&

void appearMapWithHint(const al::IUseSceneObjHolder*)

void addAmiiboHintToMap(const al::IUseSceneObjHolder*)

void appearMapWithAmiiboHint(const al::IUseSceneObjHolder*)

void appearMapMoonRockDemo(const al::IUseSceneObjHolder*, s32)

void endMap(const al::IUseSceneObjHolder*)

auto isEndMap(const al::IUseSceneObjHolder*) -> bool

auto isEnableCheckpointWarp(const al::IUseSceneObjHolder*) -> bool

auto tryShowCapMsgCollectCoinGetFirst(const al::IUseSceneObjHolder*) -> bool

void validateGlideBirdOnPlayerNose(const al::LiveActor* player)

void invalidateGlideBirdOnPlayerNose(const al::LiveActor* player)

void validateGlideBirdOnSitDownPlayerHead(const al::LiveActor* player)

void invalidateGlideBirdOnSitDownPlayerHead(const al::LiveActor* player)

auto isPlayerSitDownChair(const Bird* bird) -> bool

auto isGuardNosePainCap(const al::LiveActor*) -> bool

auto isSeparatePlay(const al::IUseSceneObjHolder*) -> bool

void calcGuidePos(sead::Vector3f*, const al::LiveActor*)

void setRouteHeadGuidePosPtr(const al::IUseSceneObjHolder*, const sead::Vector3f*)

void resetRouteHeadGuidePosPtr(const al::IUseSceneObjHolder*)

void requestShowHtmlViewer(const al::IUseSceneObjHolder*)

auto getActiveQuestNum(const al::IUseSceneObjHolder*) -> s32

auto getActiveQuestNo(const al::IUseSceneObjHolder*) -> s32

auto getActiveQuestLabel(const al::IUseSceneObjHolder*) -> const char*

void tryStartRaceStage(al::Scene*, GameDataHolder*)

auto updateNormalState(al::Scene*) -> bool

void updateEffectSystemEnv(al::Scene*)

auto updateNormalStateExcludeGraphics(al::Scene*) -> bool

auto updateBirdCarryMeat(al::Scene*) -> bool

void updateKitListExcludePlayer(al::Scene*)

void updateKitListExcludeCamera(al::Scene*)

void updateKitListExcludeCameraDemoChangeWorld(al::Scene*)

void updateKitListPlayerGroupNormal(al::Scene*)

void updateKitListDemoPlayerNoPauseEffect(al::Scene*)

void updateKitListDemoPlayerWithPauseEffect(al::Scene*)

void updateKitListDemoPlayerWithPauseEffectAndCalcAtEndClip(al::Scene*)

void updateKitListDemoNormalNoPauseEffect(al::Scene*)

void updateKitListDemoNormalWithPauseEffect(al::Scene*)

void updateKitListDemoCapWorldOpeninglWithPauseEffect(al::Scene*)

void updateKitListLayout(al::Scene*)

void updateKitListPostNoViewRenderer(al::Scene*)

void updateKitListLayoutIgnorePause(al::Scene*)

void updateKitListLayoutOnlyLayoutScene(al::Scene*)

void updateKitListPostWithPauseNormalEffectAndPlayerEffect(al::Scene*)

void updateKitListPostSnapShot(al::Scene*)

void setScenarioName(al::LayoutActor*, const al::Scene*)

void startTalkMsgTimeBalloonLayout(const al::Scene*)

void endPlayTalkMsgTimeBalloonLayout(const al::Scene*)

void endForceTalkMsgTimeBalloonLayout(const al::Scene*)

void changeDemoCommonProc(al::Scene*, ProjectItemDirector*)

void endDemoCommonProc(al::Scene*, ProjectItemDirector*)

void endDemoNormalShineGet(al::Scene*, ProjectItemDirector*)

auto tryOpenMap(al::IUseNerve*, const al::Scene*, const MapLayout*, const al::Nerve*) -> bool

auto tryChangeNextStage(GameDataHolder*, al::Scene*) -> bool

auto getPlayerActor(const al::Scene*) -> al::LiveActor*

void registerGraphicsPreset(const al::Scene*, const char*, const char*, const char*, bool)

void requestGraphicsPreset(const al::Scene*, const char*, const sead::Vector3f&)

void requestGraphicsCubeMap(const al::Scene*, const char*, const char*)

void requestGraphicsPresetAndCubeMap(const al::Scene*, const char*, const char*, const char*)

void requestGraphicsPresetAndCubeMap(const al::Scene*, const char*, const char*, const char*, const sead::Vector3f&)

void requestGraphicsPresetAndCubeMapFixedAngle(const al::Scene*, const char*, const char*, const char*)

void registerGraphicsPresetWorldMap(const al::Scene*)

void registerGraphicsPresetShop(const al::Scene*)

void registerGraphicsPresetMoonGet(const al::Scene*)

void registerGraphicsPresetCloset(const al::Scene*)

void registerGraphicsPresetPause(const al::Scene*)

void requestGraphicsPresetAndCubeMapWorldMap(const al::Scene*)

void requestGraphicsPresetAndCubeMapShop(const al::Scene*)

void requestGraphicsPresetAndCubeMapShopNoFixedAngle(const al::Scene*)

void requestGraphicsPresetAndCubeMapMoonGet(const al::Scene*)

void requestGraphicsPresetAndCubeMapMoonGetNoFixedAngle(const al::Scene*)

void requestGraphicsPresetAndCubeMapCloset(const al::Scene*)

void requestGraphicsPresetAndCubeMapClosetNoFixedAngle(const al::Scene*)

void requestGraphicsPresetAndCubeMapPause(const al::Scene*)

void requestGraphicsPresetAndCubeMapPauseNoFixedAngle(const al::Scene*)

void calcQuatPoseCheckpointWarpCap(sead::Quatf*, const sead::Vector3f&, const al::IUseCamera*)

auto getDemoDirector(const al::Scene*) -> ProjectDemoDirector*

auto getDemoShineActor(const al::Scene*) -> Shine*

auto isExistDemoShine(const al::Scene*) -> bool

void setSceneStatusBossBattle(const al::LiveActor* actor)

void setSceneStatusBossBattleEnd(const al::LiveActor* actor)

void setSceneStatusBossBattleEndForPlayerAnim(const al::LiveActor* actor)

auto isSceneStatusBossBattle(GameDataHolderAccessor accessor) -> bool

auto isSceneStatusBossBattleForPlayerAnim(const al::LiveActor* actor) -> bool

auto isSceneStatusInvalidSave(GameDataHolderAccessor accessor) -> bool

void setSceneStatusInvalidSave(GameDataHolderAccessor accessor)

auto isInvalidSaveStage(const char* stageName) -> bool

auto isWipeOpenEnd(const al::LiveActor* actor) -> bool

void endWipeOpen(const GameDataHolder* holder)

void startWipeOpen(const GameDataHolder* holder)

auto isShopStatusBuyItem(const al::LiveActor* actor) -> bool

auto isShopStatusBuyShine(const al::LiveActor* actor) -> bool

auto isShopStatusBuyShineMany(const al::LiveActor* actor) -> bool

auto isShopStatusBuyMaxLifeUpItem(const al::LiveActor* actor) -> bool

void setShopStatusBuyShine(const al::LiveActor* actor)

void setShopStatusBuyShineMany(const al::LiveActor* actor)

void setShopStatusBuyMaxLifeUpItem(const al::LiveActor* actor)

void setShopStatusNone(const al::LiveActor* actor)

auto getGameConfigData(const al::LayoutActor*) -> GameConfigData*

void saveGameConfigData(const al::LayoutActor*)

void applyGameConfigData(al::Scene*, const GameConfigData*)

auto isUseOpenListAdditionalButton(const al::IUseSceneObjHolder*) -> bool

auto createSaveObjInfoWriteSaveData(const al::ActorInitInfo& actorInitInfo) -> SaveObjInfo*

auto createSaveObjInfoWriteSaveData(const al::ActorInitInfo& actorInitInfo, const al::PlacementInfo& placementInfo) -> SaveObjInfo*

auto createSaveObjInfoNoWriteSaveDataInSameWorld(const al::ActorInitInfo& actorInitInfo) -> SaveObjInfo*

auto createSaveObjInfoNoWriteSaveDataInSameWorld(const al::ActorInitInfo& actorInitInfo, const al::PlacementInfo& placementInfo) -> SaveObjInfo*

auto createSaveObjInfoNoWriteSaveDataInSameWorldResetMiniGame(const al::ActorInitInfo& actorInitInfo) -> SaveObjInfo*

auto createSaveObjInfoNoWriteSaveDataInSameWorldResetMiniGame(const al::ActorInitInfo& actorInitInfo, const al::PlacementInfo& placementInfo) -> SaveObjInfo*

auto createSaveObjInfoNoWriteSaveDataInSameScenario(const al::ActorInitInfo& actorInitInfo) -> SaveObjInfo*

auto createSaveObjInfoNoWriteSaveDataInSameScenario(const al::ActorInitInfo& actorInitInfo, const al::PlacementInfo& placementInfo) -> SaveObjInfo*

auto createSaveObjInfoWriteSaveData(const al::ActorInitInfo& actorInitInfo, const al::PlacementId* placementId) -> SaveObjInfo*

auto createSaveObjInfoNoWriteSaveDataInSameWorld(const al::ActorInitInfo& actorInitInfo, const al::PlacementId* placementId) -> SaveObjInfo*

auto createSaveObjInfoNoWriteSaveDataInSameWorldResetMiniGame(const al::ActorInitInfo& actorInitInfo, const al::PlacementId* placementId) -> SaveObjInfo*

auto createSaveObjInfoNoWriteSaveDataInSameScenario(const al::ActorInitInfo& actorInitInfo, const al::PlacementId* placementId) -> SaveObjInfo*

void onSaveObjInfo(SaveObjInfo* saveObjInfo)

void offSaveObjInfo(SaveObjInfo* saveObjInfo)

auto isOnSaveObjInfo(const SaveObjInfo* saveObjInfo) -> bool

void setGrowFlowerTime(const al::LiveActor* actor, const al::PlacementId*, const al::PlacementId*, u64 time)

void setGrowFlowerTime(const al::LiveActor* actor, const al::PlacementId*, u64 time)

auto getGrowFlowerTime(const al::LiveActor* actor, const al::PlacementId*) -> u64

auto isUsedGrowFlowerSeed(const al::LiveActor* actor, const al::PlacementId*) -> bool

void addGrowFlowerGrowLevel(const al::LiveActor* actor, const al::PlacementId*, u32 growLevel)

auto getGrowFlowerGrowLevel(const al::LiveActor* actor, const al::PlacementId*) -> u32

auto findGrowFlowerPotIdFromSeedId(const al::LiveActor* actor, const al::PlacementId*) -> const char*

auto isPlayFirstTimeBalloon(const al::LiveActor* actor) -> bool

void playTimeBalloonFirst(const al::LiveActor* actor)

void onShortExplainGet(const al::LiveActor* actor)

void onShortExplainSet(const al::LiveActor* actor)

auto isShortExplainGet(const al::LiveActor* actor) -> bool

auto isShortExplainSet(const al::LiveActor* actor) -> bool

void onReactedLuigiCostume(const al::LiveActor* actor)

auto isReactedLuigiCostume(const al::LiveActor* actor) -> bool

auto getPlayerRank(const al::LiveActor* actor) -> s32

auto getPlayerRank(GameDataHolderAccessor accessor) -> s32

void setPlayerRank(const al::LiveActor* actor, s32 rank)

void setPlayerRank(GameDataHolderAccessor accessor, s32 rank)

auto getPrincipalId(const al::LiveActor* actor) -> u64

void setPrincipalId(const al::LiveActor* actor, u64 principalId)

auto isAnswerCorrectSphinxQuiz(GameDataHolderAccessor accessor, const char* worldName) -> bool

void answerCorrectSphinxQuiz(const al::LiveActor* actor)

auto isAnswerCorrectSphinxQuizAll(GameDataHolderAccessor accessor, const char* worldName) -> bool

void answerCorrectSphinxQuizAll(const al::LiveActor* actor)

auto isTalkAlreadyLocalLanguage(const NpcEventDirector* npcEventDirector) -> bool

void talkLocalLanguage(const al::LiveActor* actor)

auto getLocalLanguageName(const al::LiveActor* actor) -> const char*

auto getLocalLanguageName(const NpcEventDirector* npcEventDirector) -> const char*

auto isOnFlagKinopioBrigadeNpcFirstTalk(const al::LiveActor* actor) -> bool

void onFlagKinopioBrigadeNpcFirstTalk(const al::LiveActor* actor)

auto isOnFlagHintNpcFirstTalk(const al::LiveActor* actor) -> bool

void onFlagHintNpcFirstTalk(const al::LiveActor* actor)

void playScenarioStartCamera(const al::LiveActor* actor, const QuestInfo* questInfo)

void playScenarioStartCamera(const al::LiveActor* actor, s32 idx)

void setExistKoopaShip(const KoopaShip* koopaShip)

void resetExistKoopaShip(const KoopaShip* koopaShip)

auto isExistKoopaShip(const ShineTowerRocket* shineTowerRocket) -> bool

auto isExistKoopaShipInSky(const ShineTowerRocket* shineTowerRocket) -> bool

auto tryUnlockShineName(const al::LiveActor* actor, s32 shineIdx) -> bool

void calcShineIndexTableNameAvailable(s32*, s32*, const al::LiveActor* actor)

void calcShineIndexTableNameUnlockable(s32*, s32*, const al::LiveActor* actor)

auto calcWorldIdByWorldWarpHole(const WorldWarpHole* worldWarpHole, const char* changeStageId) -> s32

auto checkIsOpenWorldWarpHoleCurrentScenario(const WorldWarpHole* worldWarpHole) -> bool

auto isKidsMode(const al::LiveActor* actor) -> bool

auto isKidsMode(const al::LayoutActor* layout) -> bool

auto isKidsMode(const al::Scene* scene) -> bool

auto isKidsMode(const al::IUseSceneObjHolder* user) -> bool

auto isKidsMode(const GameDataHolder* holder) -> bool

auto isEnableCapMessageLifeOneKidsMode(const al::LiveActor* actor) -> bool

void disableCapMessageLifeOneKidsMode(const al::LiveActor* actor)

auto isInvalidChangeStage(const al::LiveActor* actor) -> bool

auto isSequenceTimeBalloonOrRace(const al::LiveActor* actor) -> bool

auto isTreasureBoxDeadStage(const al::LiveActor* actor) -> bool

void findRaceRecord(bool* isExistRecord, bool*, s32* record, s32*, s32* lapRecord, const al::LiveActor* actor, const char* raceName)

void findRaceRecord(bool* isExistRecord, bool*, s32* record, s32*, s32* lapRecord, const al::Scene* actor, const char* raceName)

void findRaceRecordRaceManRace(bool* isExistRecord, bool*, s32* record, s32*, s32* lapRecord, const al::Scene* scene)

void findRaceRecordRaceManRace(bool* isExistRecord, bool*, s32* record, s32*, s32* lapRecord, const al::LiveActor* actor)

void findRaceRecordRaceManRaceWithWorldId(bool* isExistRecord, bool*, s32* record, s32*, s32* lapRecord, const al::Scene* scene, s32 worldId)

void findRaceRecordRaceManRaceWithWorldId(bool* isExistRecord, bool*, s32* record, s32*, s32* lapRecord, const al::LiveActor* actor, s32 worldId)

void findRaceRecordRadicon(bool* isExistRecord, bool*, s32* record, s32*, s32* lapRecord, const al::Scene* scene)

void findRaceRecordRadicon(bool* isExistRecord, bool*, s32* record, s32*, s32* lapRecord, const al::LiveActor* actor)

void findRaceRecordYukimaru(bool* isExistRecord, bool*, s32* record, s32*, s32* lapRecord, const al::Scene* scene, s32 level)

void findRaceRecordYukimaru(bool* isExistRecord, bool*, s32* record, s32*, s32* lapRecord, const al::LiveActor* actor, s32 level)

void writeRaceRecord(const al::LiveActor* actor, const char* raceName, s32 record, s32, s32 lapRecord)

void writeRaceRecord(const al::Scene* scene, const char* raceName, s32 record, s32, s32 lapRecord)

auto getJumpingRopeBestCount(const al::LiveActor* actor) -> s32

auto getJumpingRopeBestCount(const al::Scene* scene) -> s32

void setJumpingRopeBestCount(const al::LiveActor* actor, s32 count)

void setJumpingRopeBestCount(const al::Scene* scene, s32 count)

auto getJumpingRopeDayCount(const al::LiveActor* actor) -> s32

void setJumpingRopeDayCount(const al::LiveActor* actor, s32 count)

void setJumpingRopeUpdateScoreFlag(const al::LiveActor* actor)

auto isExistRecordJumpingRope(const al::LiveActor* actor) -> bool

auto isExistRecordJumpingRope(const al::Scene* scene) -> bool

auto isExistRecordInDayJumpingRope(const al::LayoutActor* layout) -> bool

auto getVolleyballBestCount(const al::LiveActor* actor) -> s32

auto getVolleyballBestCount(const al::Scene* scene) -> s32

void setVolleyballBestCount(const al::LiveActor* actor, s32 count)

void setVolleyballBestCount(const al::Scene* scene, s32 count)

auto getVolleyballDayCount(const al::LiveActor* actor) -> s32

void setVolleyballDayCount(const al::LiveActor* actor, s32 count)

void setVolleyballUpdateScoreFlag(const al::LiveActor* actor)

auto isExistRecordVolleyball(const al::LiveActor* actor) -> bool

auto isExistRecordVolleyball(const al::Scene* scene) -> bool

auto isExistRecordInDayVolleyball(const al::LayoutActor* layout) -> bool

void writeRaceRecordRaceManRace(const al::LiveActor* actor, s32 record)

auto isTalkFirstAmiiboNpc(const al::LiveActor* actor) -> bool

void offFlagTalkFirstAmiiboNpc(const al::LiveActor* actor)

auto checkGetShineForWorldTravelingPeach(GameDataHolderAccessor accessor, const char* worldName) -> bool

auto checkEnableAppearMoonWorldTravelingPeach(const al::LiveActor* actor) -> bool

auto isStartWorldTravelingPeach(const al::LiveActor* actor) -> bool

void startWorldTravelingPeach(const al::LiveActor* actor)

auto checkGetEnoughShine(const al::LiveActor* actor, s32 count) -> bool

auto checkGetEnoughShineInCurrentWorld(const al::LiveActor* actor) -> bool

void setFlagOnStartKoopaCapture(const al::LiveActor* actor)

auto isStartKoopaCapture(const al::LiveActor* actor) -> bool

auto isAlreadyTalkPrevWorldInWorldWarp(const al::LiveActor* actor, s32) -> bool

auto isAlreadyTalkNextWorldInWorldWarp(const al::LiveActor* actor, s32) -> bool

void setAlreadyTalkPrevWorldInWorldWarp(const al::LiveActor* actor, s32)

void setAlreadyTalkNextWorldInWorldWarp(const al::LiveActor* actor, s32)

auto checkNeedTalkPrevWorld(const al::LiveActor* actor) -> bool

auto getTipsIdInWorldWarp(const al::LiveActor* actor) -> s32

void addTipsIdInWorldWarp(const al::LiveActor* actor)

void setTalkSpecialInWorldWarp(const al::LiveActor* actor, bool, bool)

auto isTalkFindKoopaInWorldWarp(const al::LiveActor* actor) -> bool

auto isTalkBossRaidInWorldWarp(const al::LiveActor* actor) -> bool

auto isClearMainScenario(const al::LiveActor* actor, s32 worldId) -> bool

auto checkAlreadyVisitStage(const GameDataHolder* holder, const char* stageName) -> bool

void visitStage(const GameDataHolder* holder, const char* stageName)

auto isSequenceGoToNextWorld(const al::IUseSceneObjHolder* user) -> bool

auto isSequenceCollectShineBeforeGameClear(const al::IUseSceneObjHolder* user) -> bool

auto isSequenceCollectShineForRepairHome(const al::IUseSceneObjHolder* user) -> bool

auto isSequenceCollectShine(const al::IUseSceneObjHolder* user) -> bool

auto isSequenceGoToMoonRock(const al::IUseSceneObjHolder* user) -> bool

auto isEnableExplainShopCoin(const al::LiveActor* actor) -> bool

void explainShopCoin(const al::LiveActor* actor)

auto checkShowNewItemAndPrepareSave(const al::LiveActor* actor) -> bool

auto isInNormalCoinShopFirst(const al::LiveActor* actor) -> bool

void offInNormalCoinShopFirst(const al::LiveActor* actor)

auto checkExistNewShopItem(const al::LiveActor* actor, s32, s32, bool) -> bool

auto getCapMessageBossData(const al::LiveActor* actor) -> CapMessageBossData*

void getYoshiFruit(SaveObjInfo* saveObjInfo)

auto isGetYoshiFruit(const SaveObjInfo* saveObjInfo) -> bool

auto isTalkKakku(const al::LiveActor* actor) -> bool

void talkKakku(const al::LiveActor* actor)

auto isTalkWorldTravelingPeach(const al::LiveActor* actor) -> bool

void talkWorldTravelingPeach(const al::LiveActor* actor)

auto isTalkCollectBgmNpc(const al::LiveActor* actor) -> bool

void talkCollectBgmNpc(const al::LiveActor* actor)

auto getTokimekiMayorNpcFavorabilityRating(const al::LiveActor* actor) -> s32

void setTokimekiMayorNpcFavorabilityRating(const al::LiveActor* actor, s32 rating)

auto tryFindCoinStackSave(s32*, const al::LiveActor* actor, const al::PlacementId*) -> bool

void saveCoinStack(const al::LiveActor* actor, const al::PlacementId*, s32)

auto isCollectedBgmCityWorldCelemony(const al::LiveActor* actor) -> bool

auto isCollectedBgmCityWorldCelemony2D(const al::LiveActor* actor) -> bool

auto calcGetShineNumCollectedBgm(GameDataHolderAccessor accessor) -> s32

auto checkGetShineCollectedBgmAll(const al::LiveActor* actor) -> bool

auto checkSavedHintPhoto(const al::LiveActor* actor, const char* name) -> bool

void saveHintPhoto(const al::LiveActor* actor, const char* name)

auto isRideSphinx(GameDataHolderAccessor accessor) -> bool

void rideSphinx(const al::LiveActor* actor)

auto isRideMotorcycle(GameDataHolderAccessor accessor) -> bool

void rideMotorcycle(const al::LiveActor* actor)

void setShowInformationPoleGrab(const al::IUseSceneObjHolder* user)

auto isNeedShowInformationPoleGrab(const al::IUseSceneObjHolder* user) -> bool

void setShowInformationPoleClimb(const al::IUseSceneObjHolder* user)

auto isNeedShowInformationPoleClimb(const al::IUseSceneObjHolder* user) -> bool

void setShowInformationPoleClimbTop(const al::IUseSceneObjHolder* user)

auto isNeedShowInformationPoleClimbTop(const al::IUseSceneObjHolder* user) -> bool

auto isNeedConfirmNetworkFirst(const al::IUseSceneObjHolder* user) -> bool

void saveConfirmNetworkFirst(const al::IUseSceneObjHolder* user)

auto findMapData(al::IUseSceneObjHolder*, s32) -> MapData*

auto getAchievementName(const al::IUseMessageSystem* user, const char* label) -> const char16*

auto getAchievementName(const al::LayoutActor* layout, s32 achievementIdx) -> const char16*

auto getAchievementHint(const al::IUseMessageSystem* user, const char* label) -> const char16*

auto getAchievementHint(const al::LayoutActor* layout, s32 achievementIdx) -> const char16*

auto getAchievementHolder(const al::LayoutActor* layout) -> AchievementHolder*

void unlockAchievementShineName(GameDataHolderAccessor accessor)

auto isUnlockAchievementShineName(GameDataHolderAccessor accessor) -> bool

auto checkGetAchievement(GameDataHolderAccessor accessor, const char* label) -> bool

auto checkGetAchievement(const al::LayoutActor* layout, s32 achievementIdx) -> bool

auto findAchievementGetTime(const al::LayoutActor* layout, s32 achievementIdx) -> sead::DateTime

auto findAchievementGetTime(const al::LayoutActor* layout, const char* label) -> sead::DateTime

auto findAchievementTrans(const al::LayoutActor* layout, s32 achievementIdx) -> sead::Vector3f*

auto getAchievementNum(const al::LayoutActor* layout) -> s32

auto calcReceivedAchievementNum(const GameDataHolder* holder) -> s32

auto getTotalCoinNum(const GameDataHolder* holder) -> s32

auto calcWorldWarpHoleThroughNum(const GameDataHolder* holder) -> s32

auto getWorldWarpHoleThroughNumMax(const GameDataHolder* holder) -> s32

auto calcGetCheckpointNum(const GameDataHolder* holder) -> s32

auto calcBuyItemNumForCoinCollectByWorld(const GameDataHolder* holder) -> s32

auto calcClearWorldNum(const GameDataHolder* holder) -> s32

void addPlayerJumpCount(const al::LiveActor* actor)

auto getPlayerJumpCount(const GameDataHolder* holder) -> s32

void addPlayerThrowCapCount(const al::LiveActor* actor)

auto getPlayerThrowCapCount(const GameDataHolder* holder) -> s32

auto checkGetCoinCollectAllInWorld(const al::LiveActor* actor, s32 worldId) -> bool

auto checkGetCoinCollectHalfInWorld(const AchievementNpc* achievementNpc, s32 worldId) -> bool

auto checkGetShineAllInWorld(const AchievementNpc* achievementNpc, s32 worldId) -> bool

auto checkGetClothAndCapNum(const AchievementNpc* achievementNpc, s32 num) -> bool

auto checkUnlockMoonRockAllWorld(GameDataHolderAccessor accessor) -> bool

auto calcUnlockMoonRockNum(GameDataHolderAccessor accessor) -> s32

auto calcHackObjNum(GameDataHolderAccessor accessor) -> s32

auto calcSphinxQuizCompleteNum(GameDataHolderAccessor accessor) -> s32

auto calcGetShineNumDot(const GameDataHolder* holder) -> s32

auto calcGetShineNumTreasureBox(const GameDataHolder* holder) -> s32

auto calcGetShineNumNoteObj(const GameDataHolder* holder) -> s32

auto calcGetShineNumTimerAthletic(const GameDataHolder* holder) -> s32

auto calcGetShineNumKinopioBrigade(const GameDataHolder* holder) -> s32

auto calcGetShineNumWorldTravelingPeach(const GameDataHolder* holder) -> s32

auto calcGetShineNumCollectAnimal(const GameDataHolder* holder) -> s32

auto calcAllShineNumCollectAnimal(const GameDataHolder* holder) -> s32

auto calcGetShineNumKuriboGirl(const GameDataHolder* holder) -> s32

auto calcGetShineNumJugemFish(const GameDataHolder* holder) -> s32

auto calcGetShineNumGrowPlant(const GameDataHolder* holder) -> s32

auto calcGetShineNumRabbit(const GameDataHolder* holder) -> s32

auto calcGetShineNumDigPoint(const GameDataHolder* holder) -> s32

auto calcGetShineNumCapHanger(const GameDataHolder* holder) -> s32

auto calcGetShineNumBird(const GameDataHolder* holder) -> s32

auto calcGetShineNumCostumeRoom(const GameDataHolder* holder) -> s32

auto calcGetShineNumSlot(const GameDataHolder* holder) -> s32

auto calcGetShineNumRace(const GameDataHolder* holder) -> s32

auto calcGetShineNumFigureWalking(const GameDataHolder* holder) -> s32

auto calcGetShineNumHideAndSeekCapMan(const GameDataHolder* holder) -> s32

auto calcAllShineNumHideAndSeekCapMan(const GameDataHolder* holder) -> s32

auto calcGetShineNumCollectBgmNpc(const GameDataHolder* holder) -> s32

auto calcAllShineNumCollectBgmNpc(const GameDataHolder* holder) -> s32

auto calcGetShineNumHintPhoto(const GameDataHolder* holder) -> s32

auto createDimensionKeeper(const al::LiveActor* actor) -> ActorDimensionKeeper*

auto is2D(const IUseDimension* dimension) -> bool

auto is3D(const IUseDimension* dimension) -> bool

auto isChange2D(const IUseDimension* dimension) -> bool

auto isChange3D(const IUseDimension* dimension) -> bool

auto isIn2DArea(const IUseDimension* dimension) -> bool

void updateDimensionKeeper(ActorDimensionKeeper* keeper)

auto getSpecialPurposeName2DOnly() -> const char*

void createAndSetFilter2DOnly(al::LiveActor* actor)

auto createCollisionPartsFilter2DOnly() -> al::CollisionPartsFilterOnlySpecialPurpose*

void snap2D(al::LiveActor* actor, const IUseDimension* dimension, f32 unk_distance)

void snap2DGravity(al::LiveActor* actor, const IUseDimension* dimension, f32 unk_distance)

void snap2DParallelizeFront(al::LiveActor*, const IUseDimension*, f32)

void calcSearchAmiiboBit(s32* gameId, s32* characterId, s32* characterVariant, s32 characterIdS32)

auto createCharacterIdS32(const al::NfpCharacterId& characterId) -> s32

auto isEnableUseStageSceneAmiibo(const al::NfpInfo& nfpInfo) -> bool

auto isExistAmiiboMstxtData(const al::IUseMessageSystem* user, const al::NfpInfo& nfpInfo) -> bool

auto getAmiiboMstxtLabel(bool*, const al::IUseMessageSystem* user, s32, s32, s32) -> al::StringTmp<64>

void tryFindAmiiboCostumeItemInfo(ShopItem::ItemInfo**, ShopItem::ItemInfo**, const al::NfpCharacterId& characterId, s32, al::IUseSceneObjHolder* user)

void resetHelpAmiibo(const al::IUseSceneObjHolder* user)

auto getSearchAmiiboData(const al::IUseSceneObjHolder* user) -> SearchAmiiboDataTable*

void appearCoinCollectHintEffect(const al::IUseSceneObjHolder* user)

void killCoinCollectHintEffect(const al::IUseSceneObjHolder* user)

auto tryFind2DAreaObj(const al::IUseAreaObj* user, const sead::Vector3f& trans) -> al::AreaObj*

auto tryFind2DAreaObj(const al::LiveActor* actor, sead::Vector3f*, sead::Vector3f*) -> al::AreaObj*

void calc2DAreaLockDir(sead::Vector3f* lockDir, const al::AreaObj* area, const sead::Vector3f& trans)

void get2DAreaPos(sead::Vector3f* pos, const al::AreaObj* area)

auto isIn2DArea(const al::LiveActor* actor, sead::Vector3f*, sead::Vector3f*) -> bool

auto isInChangeStage(const al::LiveActor* actor, const sead::Vector3f* trans) -> bool

auto isInWarpArea(const al::LiveActor* actor) -> bool

auto isInLowGravityArea(const al::LiveActor* actor) -> bool

auto isInItemVanishArea(const al::LiveActor* actor) -> bool

auto tryFindStageMapAreaAndGetPlayerPoint(sead::Vector3f* playerPoint, const al::IUseAreaObj* user, const sead::Vector3f& trans) -> bool

auto calcFindWaterAreaSurfaceNoWaveByArrow(const al::LiveActor* actor, sead::Vector3f*, sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&) -> bool

auto isPushOut2DAreaOpposite(const al::AreaObj* area) -> bool

auto isFaceTo2DAreaPushOutDir(const al::AreaObj* area) -> bool

void calc2DAreaFreeDir(sead::Vector3f* freeDir, const al::AreaObj* area, const sead::Vector3f& trans)

auto calc2DAreaGravity(sead::Vector3f* gravity, const al::AreaObj* area, const sead::Vector3f& trans) -> bool

auto calc2DAreaSnapPower(sead::Vector3f*, f32* snapPower, const al::AreaObj* area, const sead::Vector3f& trans) -> bool

auto calc2DAreaDistanceGravity(sead::Vector3f*, const al::AreaObj* area, const sead::Vector3f& trans) -> bool

auto get2DAreaSurfaceDistance(const al::AreaObj* area) -> f32

auto calc2DAreaSnapPowerSurfaceDistance(sead::Vector3f*, f32* snapPower, const al::AreaObj* area, const sead::Vector3f& trans, f32 surfaceDistance) -> bool

auto calcExtForceAreaVelocity(sead::Vector3f*, const al::IUseAreaObj* user, const sead::Vector3f& trans, const sead::Vector3f&, const sead::Vector3f& velocity) -> bool

auto tryFindRecoveryTargetPosArea(bool* isNoCollideGround, sead::Vector3f* targetPos, sead::Vector3f* targetRotate, const al::AreaObj** area, const al::IUseAreaObj* user, const sead::Vector3f& trans) -> bool

auto tryFindForceRecoveryArea(sead::Vector3f* targetPos, sead::Vector3f* targetRotate, const al::AreaObj** area, const al::IUseAreaObj* user, const sead::Vector3f& trans) -> bool

auto getBreakJudgeFunction(const char* name) -> break_judge_function_t

auto isEnableStartSubjectiveCamera(const al::LiveActor* actor) -> bool

auto initFollowLimitCamera(const al::IUseCamera* user, const al::ActorInitInfo& actorInitInfo, const char*) -> al::CameraTicket*

auto initParallel2DCamera(const al::IUseCamera* user, const al::ActorInitInfo& actorInitInfo, const char*) -> al::CameraTicket*

void invalidateFollowLimitCameraAutoResetLowAngleV(al::CameraTicket* ticket)

void updateCameraPosFromDistanceAndAngleHV(sead::Vector3f* newPos, const sead::Vector3f& cameraPos, f32 distance, f32 angleY, f32 angleH)

auto isPreCameraFollowOrParallel(const al::CameraStartInfo& cameraStartInfo) -> bool

auto initGetMoonCamera(const al::IUseCamera* user, const al::LiveActor* moon, const al::ActorInitInfo& actorInitInfo, const char* name, sead::Vector3f*, sead::Vector3f*, sead::Vector3f*, sead::LookAtCamera* lookAtCamera) -> al::CameraTicket*

auto initWarpCheckpointCamera(const al::IUseCamera* user, const al::LiveActor* checkpoint, const al::ActorInitInfo& actorInitInfo, const char* name, sead::Vector3f*, sead::Vector3f*, sead::Vector3f*) -> al::CameraTicket*

auto requestSetCameraAngleV(const al::LiveActor* actor, f32 requestAngleV, s32 poseUpdaterIdx) -> bool

auto requestResetCameraPosition(const al::LiveActor* actor, s32 poseUpdaterIdx) -> bool

auto requestResetCameraAngleV(const al::LiveActor* actor, s32 poseUpdaterIdx) -> bool

auto requestDownToDefaultCameraAngleBySpeed(const al::LiveActor* actor, f32 requestAngleSpeed, s32 poseUpdaterIdx) -> bool

auto requestUpToTargetCameraAngleBySpeed(const al::LiveActor* actor, f32 targetAngleV, f32 requestAngleSpeed, s32 poseUpdaterIdx) -> bool

auto requestMoveDownCameraAngleV(const al::LiveActor* actor, s32 poseUpdaterIdx) -> bool

auto requestRiseCameraAngleByPlayerCollideJumpCode(const al::LiveActor* actor) -> bool

auto requestCameraTurnToFront(const al::LiveActor* actor, f32, f32, s32 poseUpdaterIdx) -> bool

auto requestCameraTurnToFront(const al::LiveActor* actor, const sead::Vector3f& trans, f32, f32, s32 poseUpdaterIdx) -> bool

void setEquipmentCameraDistanceCurve(al::LiveActor* actor, const al::CameraDistanceCurve* curve)

void resetEquipmentCameraDistanceCurve(al::LiveActor* actor)

void setBossCameraDistanceCurve(al::LiveActor* actor, const al::CameraDistanceCurve* curve)

void resetBossCameraDistanceCurve(al::LiveActor* actor)

void setKoopaShellCameraDistanceCurve(al::LiveActor* actor)

void resetKoopaShellCameraDistanceCurve(al::LiveActor* actor)

void setTRexPatrolCameraDistanceCurve(al::LiveActor* actor)

void resetTRexPatrolCameraDistanceCurve(al::LiveActor* actor)

void buyItemInShopItemList(const al::IUseSceneObjHolder* user, s32 itemIdx)

auto isBuyItemInShopItemList(const al::IUseSceneObjHolder* user, s32 itemIdx) -> bool

void buyItem(const al::IUseSceneObjHolder* user, const ShopItem::ItemInfo* itemInfo)

void buyItemAll(const al::IUseSceneObjHolder* user)

auto isBuyItem(GameDataHolderAccessor accessor, const ShopItem::ItemInfo* itemInfo) -> bool

auto isHaveCloth(GameDataHolderAccessor accessor, const char* name) -> bool

auto isHaveCap(GameDataHolderAccessor accessor, const char* name) -> bool

auto isHaveSticker(GameDataHolderAccessor accessor, const char* name) -> bool

auto isHaveGift(GameDataHolderAccessor accessor, const char* name) -> bool

auto getClothList(GameDataHolderAccessor accessor) -> const sead::PtrArray<ShopItem::ItemInfo>&

auto getClothListSize(GameDataHolderAccessor accessor) -> s32

auto isHaveCloth(GameDataHolderAccessor accessor, s32 clothIdx) -> bool

auto isHaveClothByFileId(GameDataHolderAccessor accessor, const char* clothName, s32 fileId) -> bool

auto calcHaveClothNum(GameDataHolderAccessor accessor) -> s32

void buyCloth(const al::IUseSceneObjHolder* user, const char* clothName)

auto getCapList(GameDataHolderAccessor accessor) -> const sead::PtrArray<ShopItem::ItemInfo>&

auto getCapListSize(GameDataHolderAccessor accessor) -> s32

auto isHaveCap(GameDataHolderAccessor accessor, s32 capIdx) -> bool

auto isHaveCapByFileId(GameDataHolderAccessor accessor, const char* capName, s32 fileId) -> bool

auto isCompleteClothCap(const al::IUseSceneObjHolder* user) -> bool

auto isCompleteCloth(const al::IUseSceneObjHolder* user) -> bool

auto isCompleteCap(const al::IUseSceneObjHolder* user) -> bool

auto isCompleteCloth(const al::IUseSceneObjHolder* user, s32 fileId) -> bool

auto isCompleteCap(const al::IUseSceneObjHolder* user, s32 fileId) -> bool

auto calcHaveCapNum(GameDataHolderAccessor accessor) -> s32

void buyCap(const al::IUseSceneObjHolder* user, const char* capName)

auto getGiftList(GameDataHolderAccessor accessor) -> const sead::PtrArray<ShopItem::ItemInfo>&

auto getGiftListSize(GameDataHolderAccessor accessor) -> s32

auto isHaveGift(GameDataHolderAccessor accessor, s32 giftIdx) -> bool

auto calcHaveGiftNum(GameDataHolderAccessor accessor) -> s32

auto checkCompleteGift(GameDataHolderAccessor accessor, s32 fileId) -> bool

auto getStickerList(GameDataHolderAccessor accessor) -> const sead::PtrArray<ShopItem::ItemInfo>&

auto getStickerListSize(GameDataHolderAccessor accessor) -> s32

auto isHaveSticker(GameDataHolderAccessor accessor, s32 fileId) -> bool

auto calcHaveStickerNum(GameDataHolderAccessor accessor) -> s32

auto checkCompleteSticker(GameDataHolderAccessor accessor, s32 fileId) -> bool

auto getTestClothesName() -> const char*

auto getTestCapName() -> const char*

auto getTestGiftName() -> const char*

auto getTestStickerName() -> const char*

auto getTestItemName() -> const char*

auto getTestShineName() -> const char*

auto getMsTextName(const ShopItem::ItemType& itemType) -> const char*

auto getDisplayName(const al::IUseMessageSystem* user, const ShopItem::ItemInfo& itemInfo) -> const char16*

auto isTypeWear(const ShopItem::ShopItemInfo* itemInfo) -> bool

auto createDemoPeachWedding(const al::ActorInitInfo&) -> al::LiveActor*

auto createDemoCapManHeroine(const al::ActorInitInfo&) -> al::LiveActor*

auto isRandomActionDemoChangeWorld(const al::LiveActor*, const char*) -> bool

auto tryGetDemoChangeWorldRandomActionName(sead::BufferedSafeString*, s32*, const al::LiveActor*, const char*) -> bool

auto requestStartDemoNormal(al::LiveActor*, bool) -> bool

void addDemoActor(al::LiveActor*, bool)

void requestEndDemoNormal(const al::LiveActor*)

auto requestStartDemoNormal(const al::Scene*) -> bool

void requestEndDemoNormal(const al::Scene*)

auto requestStartDemoNormalWithCinemaFrame(al::LiveActor*) -> bool

void requestEndDemoNormalWithCinemaFrame(const al::LiveActor*)

auto requestStartDemoWithPlayer(al::LiveActor*, bool) -> bool

void requestEndDemoWithPlayer(const al::LiveActor*)

auto requestStartDemoWithPlayer(const al::Scene*) -> bool

void requestEndDemoWithPlayer(const al::Scene*)

auto requestStartDemoWithPlayerCinemaFrame(al::LiveActor*, bool) -> bool

void requestEndDemoWithPlayerCinemaFrame(const al::LiveActor*)

auto requestStartDemoWithPlayerKeepCarry(al::LiveActor*, bool) -> bool

void requestEndDemoWithPlayerKeepCarry(const al::LiveActor*)

auto requestStartDemoWithPlayerUseCoin(al::LiveActor*, bool) -> bool

void requestEndDemoWithPlayerUseCoin(const al::LiveActor*)

auto requestStartDemoWithPlayerKeepBindTalk(al::LiveActor*, bool) -> bool

void requestEndDemoWithPlayerKeepBindTalk(const al::LiveActor*)

auto requestStartDemoKeepHackTalk(al::LiveActor*, bool) -> bool

void requestEndDemoKeepHackTalk(const al::LiveActor*)

auto requestStartDemoWithPlayerCinemaFrameTalk(al::LiveActor*, bool) -> bool

void requestEndDemoWithPlayerCinemaFrameTalk(const al::LiveActor*)

auto requestStartDemoWithPlayerKeepCarryTalk(al::LiveActor*, bool) -> bool

void requestEndDemoWithPlayerKeepCarryTalk(const al::LiveActor*)

auto requestStartDemoWithPlayerUseCoinTalk(al::LiveActor*, bool) -> bool

void requestEndDemoWithPlayerUseCoinTalk(const al::LiveActor*)

auto requestStartDemoNormalTalk(al::LiveActor*, bool) -> bool

void requestEndDemoNormalTalk(const al::LiveActor*)

auto requestStartDemoWarpToCheckpoint(const al::Scene*) -> bool

auto requestStartDemoBossBattleStart(al::LiveActor*) -> bool

void requestEndDemoBossBattleStart(const al::LiveActor*)

auto requestStartDemoBossBattleEnd(al::LiveActor*) -> bool

void requestEndDemoBossBattleEnd(const al::LiveActor*)

auto requestStartDemoShineGet(Shine*) -> bool

auto requestStartDemoAchievementShineGet(al::Scene*) -> bool

void endDemoShineGet(al::Scene*)

void requestEndDemoShineGet(const al::Scene*)

void requestEndDemoShineGet(const al::LiveActor*)

auto requestStartDemoShineDotGet(Shine*) -> bool

void requestEndDemoShineDotGet(const al::Scene*)

auto requestStartDemoShineMainGet(Shine*) -> bool

void setDemoInfoDemoName(const al::LiveActor*, const char*)

void requestEndDemoShineMainGet(const al::LiveActor*)

void requestEndDemoShineMainGet(const al::Scene*)

auto requestStartDemoShineGrandGet(Shine*) -> bool

void requestEndDemoShineGrandGet(const al::LiveActor*)

void requestEndDemoShineGrandGet(const al::Scene*)

auto requestStartDemoShineAppear(al::LiveActor*) -> bool

void requestEndDemoShineAppear(const al::LiveActor*)

auto requestStartDemoShineAppear(const al::Scene*) -> bool

void requestEndDemoShineAppear(const al::Scene*)

auto requestStartDemoWarp(al::LiveActor*) -> bool

auto requestStartDemoWarp(const al::Scene*) -> bool

void requestEndDemoWarp(const al::LiveActor*)

void requestEndDemoWarp(const al::Scene*)

auto requestStartDemoHackStart(al::LiveActor*) -> bool

void requestEndDemoHackStart(const al::LiveActor*)

auto requestStartDemoAppearByBazookaElectric(al::LiveActor*) -> bool

void requestEndDemoAppearByBazookaElectric(const al::LiveActor*)

auto requestStartDemoLaunchBazookaElectric(al::LiveActor*) -> bool

void requestEndDemoLaunchBazookaElectric(const al::LiveActor*)

auto requestStartDemoSceneStartPlayerWalk(al::LiveActor*) -> bool

void requestEndDemoSceneStartPlayerWalk(const al::LiveActor*)

auto requestStartDemoGetLifeMaxUpItem(al::LiveActor*) -> bool

void requestEndDemoGetLifeMaxUpItem(const al::Scene*)

auto requestStartDemoBirdCarryMeat(al::LiveActor*) -> bool

void requestEndDemoBirdCarryMeat(const al::LiveActor*)

auto requestStartDemoBirdFindMeat(al::LiveActor*) -> bool

void requestEndDemoBirdFindMeat(const al::LiveActor*)

auto requestStartDemoGetTimeBalloon(al::LiveActor*) -> bool

void requestEndDemoGetTimeBalloon(const al::LiveActor*)

auto requestStartDemoJango(al::LiveActor*) -> bool

void requestEndDemoJango(const al::LiveActor*)

auto requestStartDemoTitleLogo(const al::LiveActor*) -> bool

auto requestStartDemoGoToEnding(al::LiveActor*) -> bool

auto isActiveDemo(const al::LiveActor*) -> bool

auto isActiveDemo(const al::Scene*) -> bool

auto isActiveDemoNormal(const al::Scene*) -> bool

auto isActiveDemoNormalWithCinemaFrame(const al::Scene*) -> bool

auto isActiveDemoWithPlayer(const al::Scene*) -> bool

auto isActiveDemoWithPlayer(const al::LiveActor*) -> bool

auto isActiveDemoWithPlayerCinemaFrame(const al::Scene*) -> bool

auto isActiveDemoWithPlayerCinemaFrame(const al::LiveActor*) -> bool

auto isActiveDemoWithPlayerKeepCarry(const al::Scene*) -> bool

auto isActiveDemoWithPlayerKeepCarry(const al::LiveActor*) -> bool

auto isActiveDemoWithPlayerUseCoin(const al::Scene*) -> bool

auto isActiveDemoWithPlayerUseCoin(const al::LiveActor*) -> bool

auto isActiveDemoWithPlayerKeepBindTalk(const al::Scene*) -> bool

auto isActiveDemoWithPlayerKeepBindTalk(const al::LiveActor*) -> bool

auto isActiveDemoWarpToCheckpoint(const al::LiveActor*) -> bool

auto isActiveDemoShineGet(const al::Scene*) -> bool

auto isActiveDemoShineGet(const al::LiveActor*) -> bool

auto isActiveDemoShineDotGet(const al::Scene*) -> bool

auto isActiveDemoShineDotGet(const al::LiveActor*) -> bool

auto isActiveDemoShineGrandGet(const al::Scene*) -> bool

auto isActiveDemoShineGrandGet(const al::LiveActor*) -> bool

auto isActiveDemoShineMainGet(const al::Scene*) -> bool

auto isActiveDemoShineMainGet(const al::LiveActor*) -> bool

auto isActiveDemoWarp(const al::Scene*) -> bool

auto isActiveDemoWarp(const al::LiveActor*) -> bool

auto isActiveDemoHackStart(const al::LiveActor*) -> bool

auto isActiveDemoHackStart(const al::Scene*) -> bool

auto isActiveDemoHackStartFirst(const al::Scene*) -> bool

auto isEqualDemoInfoDemoName(const al::Scene*, const char*) -> bool

auto isActiveDemoScenarioCamera(const al::LiveActor*) -> bool

auto isActiveDemoGetLifeMaxUpItem(const al::Scene*) -> bool

auto isActiveDemoSceneStartPlayerWalk(const al::Scene*) -> bool

auto isActiveDemoBirdCarryMeat(const al::Scene*) -> bool

auto isActiveDemoBirdFindMeat(const al::Scene*) -> bool

auto isActiveDemoJango(const al::Scene*) -> bool

auto isActiveDemoJango(const al::LiveActor*) -> bool

auto isActiveDemoTitleLogo(const al::Scene*) -> bool

auto isActiveDemoGoToEnding(const al::Scene*) -> bool

auto isActiveDemoTalk(const al::Scene*) -> bool

auto isActiveDemoCinemaFrameTalk(const al::Scene*) -> bool

auto isActiveDemoKeepCarryTalk(const al::Scene*) -> bool

auto isActiveDemoUseCoinTalk(const al::Scene*) -> bool

auto isActiveDemoKeepHackTalk(const al::Scene*) -> bool

auto isActiveDemoNormalTalk(const al::Scene*) -> bool

auto isActiveDemoLaunchBazookaElectric(const al::Scene*) -> bool

auto isActiveDemoGiantWanderBossBattleStart(const al::Scene*) -> bool

auto isActiveDemoGiantWanderBossBattleStart(const OceanWaveActor*) -> bool

auto isActiveDemoPlayerPuppetable(const al::LiveActor*) -> bool

void addDemoSubActor(al::LiveActor*)

void registerShineTowerRocketToDemoDirector(ShineTowerRocket*)

auto tryGetShineTowerRocketFromDemoDirector(al::LiveActor*) -> ShineTowerRocket*

void addDemoAppearFromHomeToList(ShineTowerRocket*)

void addDemoReturnToHomeToList(ShineTowerRocket*)

void addDemoRiseMapPartsToList(RiseMapPartsHolder*)

auto requestStartDemoWorldIntroCamera(const al::Scene*) -> bool

void requestEndDemoWorldIntroCamera(const al::Scene*)

auto requestStartDemoScenarioCamera(const al::Scene*) -> bool

void requestEndDemoScenarioCamera(const al::LiveActor*)

auto requestStartDemoAppearFromHome(const al::Scene*) -> bool

void requestEndDemoAppearFromHome(const al::LiveActor*)

auto requestStartDemoReturnToHome(const al::Scene*) -> bool

void requestEndDemoReturnToHome(const al::LiveActor*)

auto requestStartDemoRiseMapParts(const al::Scene*) -> bool

void requestEndDemoRiseMapParts(const al::LiveActor*)

auto requestStartDemoPeachCastleCap(al::LiveActor*) -> bool

void requestEndDemoPeachCastleCap(const al::LiveActor*)

auto isExistDemoAppearFromHomeInList(const al::Scene*) -> bool

auto isExistDemoReturnToHome(const al::Scene*) -> bool

auto isExistDemoRiseMapPartsInList(const al::Scene*) -> bool

auto getRequestActor(const al::Scene*) -> al::LiveActor*

void requestValidateDemoSkip(IUseDemoSkip*, const al::LiveActor*)

auto getDemoSkipRequester(const al::Scene*) -> IUseDemoSkip*

auto isDemoEnableSkip(const al::Scene*) -> bool

auto isFirstDemo(const al::Scene*) -> bool

auto isEnableSkipDemo(const al::Scene*) -> bool

void skipDemo(const al::Scene*)

void updateOnlyDemoGraphics(const al::Scene*)

auto isFirstDemoWorldIntroCamera(const al::Scene*) -> bool

auto isFirstDemoScenarioStartCamera(const al::LiveActor*) -> bool

void noticeDemoSkipStart(const al::Scene*)

void noticeDemoSkipEnd(const al::Scene*)

auto isWaitDemoSkipEnd(const al::LiveActor*) -> bool

auto createCaptionInfoHolder(const char*) -> CaptionInfoHolder*

void validateDemoCaption(const al::LiveActor*, CaptionInfoHolder*)

auto isActiveDemoWithCinemaCaption(const al::Scene*) -> bool

auto tryAppearCinemaCaption(const al::Scene*, CinemaCaption*) -> bool

void startCloseDemoFade(const al::LiveActor*, s32)

void startOpenDemoFade(const al::LiveActor*, s32)

auto isDemoFadeCloseEnd(const al::LiveActor*) -> bool

auto isDemoFadeOpenEnd(const al::LiveActor*) -> bool

auto isDemoFadeWipeStateEnableOpenMenuOrSnapShotMode(const al::Scene*) -> bool

auto tryCreateDemoHackFirstDirector(al::LiveActor*, s32, const al::ActorInitInfo&) -> DemoHackFirstDirector*

void noticeDemoStartToDemoHackFirstDirector(const al::Scene*)

void setBossBarrierField(BarrierField*)

auto tryGetBossBarrierField(const al::LiveActor*) -> BarrierField*

void setDemoEnvironmentChangeFlag(const al::Scene*, bool)

void setDemoEnvironmentChangeFlag(const al::LiveActor*, bool)

auto isDemoEnvironmentChange(const al::Scene*) -> bool

auto isDemoEnvironmentChange(const al::LiveActor*) -> bool

auto getRandomActionIndexDemoChangeWorld(const al::LiveActor*) -> s32

void setDemoInfoDemoName(const al::Scene*, const char*)

void getDemoInfoDemoName(const al::LiveActor*)

auto isTriggerDemoCancel(const al::IUseSceneObjHolder*) -> bool

void updateDemoSystemOnly(const al::Scene*)

void notifyDisableUpdateCamera(const al::LiveActor*)

auto isDisableUpdateCamera(const al::Scene*) -> bool

auto createCapTargetInfo(al::LiveActor*, const char*) -> CapTargetInfo*

auto createCapTargetInfoWithPlayerCollider(al::LiveActor*, IUsePlayerCollision*, const char*) -> CapTargetInfo*

auto createCapTargetInfoHackMapParts(al::LiveActor*) -> CapTargetInfo*

auto createCapTargetInfoLockOnOnlyNoArchive(al::LiveActor*, const sead::Matrix34f*) -> CapTargetInfo*

void requestLockOnCapHitReaction(const al::LiveActor*, const CapTargetInfo*, const char*)

auto startHack(al::HitSensor*, al::HitSensor*, al::LiveActor*) -> IUsePlayerHack*

void endHack(IUsePlayerHack**)

void endHackDir(IUsePlayerHack**, const sead::Vector3f&)

void endHackTargetQuat(IUsePlayerHack**, const sead::Quatf&, const sead::Vector3f&)

void endHackFromTargetPos(IUsePlayerHack**, const sead::Vector3f&)

void endHackFromTargetPos(IUsePlayerHack**, const sead::Vector3f&, const sead::Vector3f&)

void endHackFromTargetPos(IUsePlayerHack**, const sead::Vector3f&, const sead::Quatf&, const sead::Vector3f&)

void endHackWithDamage(IUsePlayerHack**)

void endHackWithDamageAndVelocity(IUsePlayerHack**, const sead::Vector3f&)

void endHackEscapeScale(IUsePlayerHack**, f32)

void endHackDirEscapeScale(IUsePlayerHack**, const sead::Vector3f&, f32)

void endHackDirEscapeScalePose(IUsePlayerHack**, const sead::Quatf&, const sead::Vector3f&, f32)

void endHackAirVelocity(IUsePlayerHack**, const sead::Vector3f&, const sead::Quatf&, const sead::Vector3f&, s32)

void endHackElectricWireToDestination(IUsePlayerHack**, const sead::Vector3f&, const sead::Vector3f&)

void endHackFastenerToDestination(IUsePlayerHack**, const sead::Vector3f&, const sead::Vector3f&)

void endHackBazookaElectricToDestination(IUsePlayerHack**, const sead::Vector3f&, const sead::Vector3f&, const sead::Quatf&, s32, f32)

void endHackThrowed(IUsePlayerHack**, const sead::Vector3f&)

auto requestDamage(IUsePlayerHack*) -> bool

void syncDamageVisibility(al::LiveActor*, const IUsePlayerHack*)

auto isDamageVisibilityHide(const IUsePlayerHack*) -> bool

auto isTouchHackCancelCollisionCode(const al::LiveActor*, const IUsePlayerCollision*) -> bool

auto isTouchHackDamageCollisionCode(const al::LiveActor*, const IUsePlayerCollision*) -> bool

void updateMaterialCode(al::LiveActor*, const IUsePlayerCollision*)

auto startHackStartDemo(IUsePlayerHack*, al::LiveActor*) -> IUsePlayerHack*

auto startHackStartDemoPuppetable(IUsePlayerHack*, al::LiveActor*) -> IUsePlayerHack*

void addHackStartDemoActor(IUsePlayerHack*, al::LiveActor*)

void endHackStartDemo(IUsePlayerHack*, al::LiveActor*)

auto tryEndHackStartDemo(IUsePlayerHack*, al::LiveActor*) -> bool

auto isActiveHackStartDemo(const IUsePlayerHack*) -> bool

auto isHackStartDemoEnterMario(const IUsePlayerHack*) -> bool

auto isHackerStopMove(const al::LiveActor*, const IUsePlayerHack*, f32) -> bool

auto isHackerStopMoveGround(const al::LiveActor*, const IUsePlayerHack*, f32, const IUsePlayerCollision*) -> bool

auto sendMsgHackerNoReaction(const IUsePlayerHack*, al::HitSensor*, al::HitSensor*) -> bool

auto sendMsgHackerNoReactionWithoutShine(const IUsePlayerHack*, al::HitSensor*, al::HitSensor*) -> bool

auto isMsgHackerDamageAndCancel(const al::SensorMsg*) -> bool

auto isMsgEnableMapCheckPointWarpCollidedGround(const al::SensorMsg*, const al::LiveActor*) -> bool

auto isMsgEnableMapCheckPointWarpCollidedGround(const al::SensorMsg*, const IUsePlayerCollision*) -> bool

auto receiveMsgRequestTransferHack(const al::SensorMsg*, IUsePlayerHack*, al::HitSensor*) -> bool

void hideHackCap(IUsePlayerHack*)

void showHackCap(IUsePlayerHack*)

void hideShadowHackCap(IUsePlayerHack*)

auto isHackCapSeparateFlying(IUsePlayerHack*) -> bool

void calcGroundHeightHackerDepthShadowMapLength(al::LiveActor*, const IUsePlayerHack*, const sead::Vector3f&, f32, f32)

void cutGroundHeightHackerDepthShadowMapLength(al::LiveActor*, const IUsePlayerHack*, const char*, const sead::Vector3f&, f32, f32)

void checkExistHeightSpaceAboveGround(f32*, const IUsePlayerHack*, f32)

void requestRecoverySafetyPoint(IUsePlayerHack*, const sead::Vector3f&, const sead::Vector3f&)

auto trySnapTransToSnapMoveArea(al::LiveActor*, bool, const sead::Vector3f&, f32) -> bool

void updateHackActorVisibilityBySeparatePlay(al::LiveActor*, IUsePlayerHack*, const char*, const char*)

void startReset(al::LiveActor*)

void endReset(al::LiveActor*)

void calcHackerMoveVec(sead::Vector3f*, const IUsePlayerHack*, const sead::Vector3f&)

auto calcHackerMoveDir(sead::Vector3f*, const IUsePlayerHack*, const sead::Vector3f&) -> bool

void calcHackerWallInputVec(sead::Vector3f*, sead::Vector3f*, const IUsePlayerHack*, const sead::Vector3f&)

void calcHackerWallInputVec(sead::Vector3f*, sead::Vector3f*, const sead::Vector2f&, const sead::Vector3f&)

auto getHackMoveStickRaw(const IUsePlayerHack*) -> f32

void calcHackerWallInputDir(sead::Vector3f*, sead::Vector3f*, const IUsePlayerHack*, const sead::Vector3f&)

auto addHackActorAccelStick(al::LiveActor*, const IUsePlayerHack*, sead::Vector3f*, f32, const sead::Vector3f&) -> bool

void calcHackMovePower(const IUsePlayerHack*)

void checkHackerMoveDir(const IUsePlayerHack*, const sead::Vector3f&, const sead::Vector3f&, f32)

void calcHackerTrampleJumpParam(f32*, f32*, s32*, al::LiveActor*, const IUsePlayerHack*, f32, f32, f32, f32, f32, s32, f32, f32, f32, f32, f32)

auto isOnHackMoveStick(const IUsePlayerHack*) -> bool

auto isHoldHackJump(const IUsePlayerHack*) -> bool

auto isOnHackMoveStickDeepDown(const IUsePlayerHack*) -> bool

auto isOnHackMoveStickGreater(const IUsePlayerHack*, f32) -> bool

auto isTriggerHackAction(const IUsePlayerHack*) -> bool

auto isTriggerHackPreInputAction(const IUsePlayerHack*) -> bool

auto isHoldHackAction(const IUsePlayerHack*) -> bool

auto isReleaseHackAction(const IUsePlayerHack*) -> bool

auto isTriggerHackJump(const IUsePlayerHack*) -> bool

auto isTriggerHackPreInputJump(const IUsePlayerHack*) -> bool

auto isReleaseHackJump(const IUsePlayerHack*) -> bool

auto isTriggerHackAnyButton(const IUsePlayerHack*) -> bool

auto isTriggerHackPreInputAnyButton(const IUsePlayerHack*) -> bool

auto isHoldHackAnyButton(const IUsePlayerHack*) -> bool

auto isReleaseHackAnyButton(const IUsePlayerHack*) -> bool

auto isTriggerHackSeparateJump(const IUsePlayerHack*) -> bool

auto isHoldHackSeparateJump(const IUsePlayerHack*) -> bool

void getHackStickRotateSpeed(const IUsePlayerHack*)

auto isTriggerHackSwing(const IUsePlayerHack*) -> bool

auto isTriggerHackSwingDirLeft(const IUsePlayerHack*) -> bool

auto isTriggerHackSwingDirRight(const IUsePlayerHack*) -> bool

auto isTriggerHackSwingDoubleHand(const IUsePlayerHack*) -> bool

auto isTriggerHackSwingDoubleHandReverseDir(const IUsePlayerHack*) -> bool

auto isTriggerHackSwingDoubleHandReverseInsideDir(const IUsePlayerHack*) -> bool

auto isTriggerHackSwingDoubleHandReverseOutsideDir(const IUsePlayerHack*) -> bool

void getHackPoseRotZDegreeLeft(const IUsePlayerHack*)

void getHackPoseRotZDegreeRight(const IUsePlayerHack*)

auto isTriggerTankCameraReset(const IUsePlayerHack*) -> bool

auto isTriggerHackSwingLeftHand(const IUsePlayerHack*) -> bool

auto isTriggerHackSwingRightHand(const IUsePlayerHack*) -> bool

void getHackSwingThrowDir(const IUsePlayerHack*)

void getHackSwingLeftHandDir(const IUsePlayerHack*)

void getHackSwingRightHandDir(const IUsePlayerHack*)

void getHackSwingVelLeftHand(const IUsePlayerHack*)

void getHackSwingVelRightHand(const IUsePlayerHack*)

void getHackCameraStickRaw(const IUsePlayerHack*)

void getRadiconInputSteeringValue(const IUsePlayerHack*)

void getRadiconInputThrottleValue(const IUsePlayerHack*)

auto isTriggerRecorderPlay(const IUsePlayerHack*) -> bool

auto isTriggerRecorderReverse(const IUsePlayerHack*) -> bool

auto isHoldRecorderPlay(const IUsePlayerHack*) -> bool

auto isHoldRecorderReverse(const IUsePlayerHack*) -> bool

auto isTriggerRecorderJump(const IUsePlayerHack*) -> bool

auto isTriggerRecorderCancel(const IUsePlayerHack*) -> bool

void getHackGemyLeftStickRaw()

void getHackGemyRightStickRaw()

auto isTriggerGemyResetCamera(const IUsePlayerHack*) -> bool

auto isTriggerGemyChangeCamera(const IUsePlayerHack*) -> bool

auto isTriggerSubjectiveCamera(const IUsePlayerHack*) -> bool

auto isTriggerFlutter(const IUsePlayerHack*, f32) -> bool

auto isTriggerFukankunZoomOn(const IUsePlayerHack*) -> bool

auto isTriggerFukankunZoomOff(const IUsePlayerHack*) -> bool

auto isHoldFukankunZoom(const IUsePlayerHack*) -> bool

void getPoleJumpPadPoseMtx(sead::Matrix33f*)

void getPoleJumpPadAcceleration(sead::Vector3f*)

auto isTriggerIceClimberClimbLeft(const IUsePlayerHack*) -> bool

auto isTriggerIceClimberClimbRight(const IUsePlayerHack*) -> bool

auto isTriggerIceClimberFall(const IUsePlayerHack*) -> bool

auto tryCloseHackTutorial(const al::IUseSceneObjHolder*) -> bool

void changeHackTutorialText(const al::IUseSceneObjHolder*, const char*)

void resetHackTutorialText(const al::IUseSceneObjHolder*)

void tryAppearBindTutorial(const al::IUseSceneObjHolder*, const BindInfo&)

auto tryCloseBindTutorial(const al::IUseSceneObjHolder*) -> bool

auto tryCloseObjectTutorial(const al::IUseSceneObjHolder*, const char*) -> bool

void appearFirstHackTutorialFrog(const al::IUseSceneObjHolder*)

void appearFirstHackTutorialKoopa(const al::IUseSceneObjHolder*)

auto tryAppearObjectTutorial(const al::IUseSceneObjHolder*, const char*) -> bool

auto tryAppearObjectTutorialOpening(const al::IUseSceneObjHolder*, const char*, const char*) -> bool

auto tryCloseObjectTutorialOpening(const al::IUseSceneObjHolder*, const char*) -> bool

auto tryAppearObjectTutorialHipDrop(const al::IUseSceneObjHolder*) -> bool

auto tryCloseObjectTutorialHipDrop(const al::IUseSceneObjHolder*) -> bool

auto tryAppearObjectTutorialCapThrow(const al::IUseSceneObjHolder*) -> bool

auto tryCloseObjectTutorialCapThrow(const al::IUseSceneObjHolder*) -> bool

void tryAppearPlayerGrabPoleTutorial(const al::IUseSceneObjHolder*)

void tryClosePlayerGrabPoleTutorial(const al::IUseSceneObjHolder*)

void tryAppearPlayerClimbPoleTutorial(const al::IUseSceneObjHolder*)

void tryClosePlayerClimbPoleTutorial(const al::IUseSceneObjHolder*)

void tryAppearPlayerClimbPoleTopTutorial(const al::IUseSceneObjHolder*)

void tryClosePlayerClimbPoleTopTutorial(const al::IUseSceneObjHolder*)

void tryAppearKoopaCapTutorial(const al::IUseSceneObjHolder*)

void tryAppearKoopaCapTutorialNoMovie(const al::IUseSceneObjHolder*)

void tryCloseKoopaCapTutorial(const al::IUseSceneObjHolder*)

void changeSeparatePlayTutorial(const al::IUseSceneObjHolder*)

void changeSinglePlayTutorial(const al::IUseSceneObjHolder*)

void changeEnableCapTutorial(const al::IUseSceneObjHolder*)

void changeDisableCapTutorial(const al::IUseSceneObjHolder*)

void tryAppearSignboardTutorial(const al::IUseSceneObjHolder*, const char*)

auto isExistSignboardTutorialMovie(const al::IUseSceneObjHolder*, const char*) -> bool

void tryCloseSignboardTutorial(const al::IUseSceneObjHolder*)

void tryAppearAmiiboHelpNpcTutorial(const al::IUseSceneObjHolder*)

void tryAppearAmiiboHelpNpcSeparateTutorial(const al::IUseSceneObjHolder*)

auto tryAppearPlayerCameraSubjectiveTutorial(const al::IUseSceneObjHolder*) -> bool

void tryClosePlayerCameraSubjectiveTutorial(const al::IUseSceneObjHolder*)

void appearCapMsgTutorial(const al::IUseSceneObjHolder*, const char*)

void closeCapMsgTutorial(const al::IUseSceneObjHolder*)

void appearRaceTutorial(const al::IUseSceneObjHolder*, const char*)

void killRaceTutorial(const al::IUseSceneObjHolder*, const char*)

void appearRaceTutorialTutorial(const al::IUseSceneObjHolder*)

auto isShowTutorial(const al::IUseSceneObjHolder*) -> bool

auto isShowObjectTutorial(const al::IUseSceneObjHolder*, const char*) -> bool

void hideTutorial(const al::IUseSceneObjHolder*)

void showTutorial(const al::IUseSceneObjHolder*)

void appearTutorialForDemo(const al::IUseSceneObjHolder*)

void killTutorial(const al::IUseSceneObjHolder*)

void updateGyroText(const al::IUseSceneObjHolder*)

auto getItemType(const al::ActorInitInfo& info) -> ItemType::ValueType

auto getItemTypeFromName(const char* name) -> ItemType::ValueType

auto getItemType(const char* name) -> ItemType::ValueType

auto isItemTypeKuriboMini(s32* out, s32 type) -> bool

auto tryInitItemAndAddToKeeper(al::LiveActor* actor, s32 itemType, const al::ActorInitInfo& info, bool isAppearAbove) -> bool

void initItemByPlacementInfo(al::LiveActor* actor, const al::ActorInitInfo& info, bool isAppearAbove)

auto tryInitItemByPlacementInfo(al::LiveActor* actor, const al::ActorInitInfo& info, bool isAppearAbove) -> bool

void initItem2DByPlacementInfo(al::LiveActor* actor, const al::ActorInitInfo& info)

auto tryInitItem2DByPlacementInfo(al::LiveActor* actor, const al::ActorInitInfo& info) -> bool

auto tryInitItem(al::LiveActor* actor, s32 itemType, const al::ActorInitInfo& info, bool isAppearAbove) -> bool

auto tryInitShineByPlacementInfoWithItemMenu(const al::ActorInitInfo& info) -> Shine*

auto initShineByPlacementInfo(const al::ActorInitInfo& info) -> Shine*

auto tryInitLinkShine(const al::ActorInitInfo& info, const char* name, s32 linkIndex) -> Shine*

auto tryInitLinkShineHintPhoto(const al::ActorInitInfo& info, const char* name, s32 linkIndex) -> Shine*

auto initLinkShine(const al::ActorInitInfo& info, const char* name, s32 linkIndex) -> Shine*

auto initLinkShopShine(const al::ActorInitInfo& info, const char* name) -> Shine*

auto initLinkShineChipShine(const al::ActorInitInfo& info) -> Shine*

auto initLinkBossShine(const al::ActorInitInfo& info) -> Shine*

void createShineEffectInsideObject(Shine* shine, const al::LiveActor* actor, const al::ActorInitInfo& info)

void appearPopupShine(Shine* shine)

void appearPopupShine(Shine* shine, const al::LiveActor* actor)

void appearPopupShine(Shine* shine, const sead::Vector3f& trans)

void appearPopupShineWithoutDemo(Shine* shine)

void appearPopupShineWithoutDemo(Shine* shine, const al::LiveActor* actor)

void appearPopupShineWithoutDemo(Shine* shine, const sead::Vector3f& trans)

void appearPopupShineWithoutWarp(Shine* shine)

void appearPopupShineGrandByBoss(Shine* shine, s32 a2)

void appearWaitShine(Shine* shine)

void appearWaitShine(Shine* shine, const sead::Vector3f& trans)

auto isEndAppearShine(const Shine* shine) -> bool

auto isGotShine(const Shine* shine) -> bool

auto isAliveShine(const Shine* shine) -> bool

auto isMainShine(const Shine* shine) -> bool

void updateHintTrans(const Shine* shine, const sead::Vector3f& trans)

void appearShineAndJoinBossDemo(Shine* shine, const char* name, const sead::Quatf& quat, const sead::Vector3f& trans)

void endShineBossDemo(Shine* shine)

void endShineBossDemoAndStartFall(Shine* shine, f32 a2)

void setAppearItemFactorByMsg(const al::LiveActor* actor, const al::SensorMsg* msg, const al::HitSensor* sensor)

void setAppearItemFactorAndOffsetByMsg(const al::LiveActor* actor, const al::SensorMsg* msg, const al::HitSensor* sensor)

void setAppearItemFactorAndOffsetForCombo(const al::LiveActor* actor, const al::SensorMsg* msg, const al::HitSensor* sensor, bool isSuperCombo)

void appearItemFromObj(al::LiveActor* actor, const sead::Vector3f& trans, const sead::Quatf& quat, f32 offset)

void appearItemFromObj(al::LiveActor* actor, al::HitSensor* sensor, f32 offset)

void appearItemFromObj(al::LiveActor* actor, al::HitSensor* sensor, const sead::Vector3f& offset)

void appearItemFromObjGravity(al::LiveActor* actor, al::HitSensor* sensor, const sead::Vector3f& offset)

auto tryAppearMultiCoinFromObj(al::LiveActor* actor, const sead::Vector3f& trans, s32 step, f32 offsetAbove) -> bool

auto tryAppearMultiCoinFromObj(al::LiveActor* actor, const sead::Vector3f& trans, const sead::Quatf& quat, s32 step, f32 offsetAbove) -> bool

auto tryAppearMultiCoinFromObj(al::LiveActor* actor, al::HitSensor* sensor, s32 step, f32 offsetAbove) -> bool

auto tryAppearMultiCoinFromObj(al::LiveActor* actor, al::HitSensor* sensor, s32 step, const sead::Vector3f& offset) -> bool

void syncCoin2DAnimFrame(al::LiveActor* actor, const char* name)

auto getStageCoinCollectArchiveName(const al::LiveActor* actor) -> const char*

auto getStageCoinCollectEmptyArchiveName(const al::LiveActor* actor) -> const char*

auto getStageCoinCollect2DArchiveName(const al::LiveActor* actor) -> const char*

auto getStageCoinCollect2DEmptyArchiveName(const al::LiveActor* actor) -> const char*

auto getStageShineAnimFrame(const al::LiveActor* actor) -> s32

auto getStageShineAnimFrame(const al::LiveActor* actor, s32 worldId) -> s32

auto getStageShineAnimFrame(const al::LiveActor* actor, const char* stageName) -> s32

void startShineAnimAndSetFrameAndStop(al::LiveActor* actor, const char* animName, s32 frame, bool isMatAnim)

void setStageShineAnimFrame(al::LiveActor* actor, const char* stageName, s32 shineAnimFrame, bool isMatAnim)

auto getStageShineArchiveName(const al::LiveActor* actor, const char* stageName) -> const char*

auto getStageShineEmptyArchiveName(const al::LiveActor* actor, const char* stageName) -> const char*

void setMaterialAsEmptyModel(al::LiveActor* actor)

void setProjectionMtxAsEmptyModel2d(al::LiveActor* actor, const sead::Vector2f& vec)

SEAD_ENUM(ItemType, None = -1, Coin, Coin2D, CoinBlow, CoinBlowVeryLittle, CoinPopUp, CoinPopUpWithoutHitReaction, Coin3, Coin5, Coin10, Coin10Auto, Coin5Count, Coin100, LifeUpItem, LifeUpItemBack, LifeUpItem2D, LifeMaxUpItem, LifeMaxUpItem2D, Shine, AirBubble, DotMarioCat, KuriboMini3, KuriboMini8, CoinStackBound, Random)

void appearRandomItemFromObj(al::LiveActor* actor, al::HitSensor* sensor, f32 offset)

void addDemoRacePrizeCoin(al::LiveActor* actor)

void resetJudge(IJudge* judge)

void updateJudge(IJudge* judge)

auto isJudge(const IJudge* judge) -> bool

auto updateJudgeAndResult(IJudge* judge) -> bool

auto judgeAndResetReturnTrue(IJudge* judge) -> bool

auto isEnableShowDemoAfterOpenMoonRockFirst(const al::LiveActor* actor) -> bool

auto isFirstDemoOpenMoonRock(const al::LiveActor* actor) -> bool

auto isEnableShowDemoMoonRockMapWorld(const al::LiveActor* actor) -> bool

void showDemoAfterOpenMoonRockFirst(const al::LiveActor* actor)

void showDemoMoonRockMapWorld(const al::LiveActor* actor)

auto getNetworkPrototypeDirectory() -> const char*

void convertComputerNameToFullName(sead::BufferedSafeString* fullName, const char* computerName)

void convertComputerNameToSecondName(sead::BufferedSafeString* secondName, const char* computerName)

void convertComputerNameToSecondKanaName(sead::BufferedSafeString* secondKanaName, const char* computerName)

auto tryApplyNpcMaterialAnimPresetFromPlacementInfo(al::LiveActor*, const al::ActorInitInfo&, const TalkNpcParam*) -> bool

void setNpcMaterialAnimFromPlacementInfo(al::LiveActor*, const al::ActorInitInfo&)

auto tryUpdateNpcEyeLineAnim(al::LiveActor*, const TalkNpcParam*) -> bool

auto tryUpdateNpcEyeLineAnimToTarget(al::LiveActor*, const TalkNpcParam*, const sead::Vector3f&, bool) -> bool

void resetNpcEyeLineAnim(al::LiveActor*)

auto tryUpdateNpcFacialAnim(al::LiveActor*, const TalkNpcParam*) -> bool

void trySwitchDepthToSelfShadow(al::LiveActor*)

auto tryReceiveMsgPlayerDisregard(const al::SensorMsg*, al::HitSensor*, const TalkNpcParam*) -> bool

void attackSensorNpcCommon(al::HitSensor*, al::HitSensor*)

auto receiveMsgNpcCommonNoReaction(const al::SensorMsg*, al::HitSensor*, al::HitSensor*) -> bool

void calcNpcPushVecBetweenSensors(sead::Vector3f*, al::HitSensor*, al::HitSensor*)

auto createAndAppendNpcJointLookAtController(al::LiveActor*, const TalkNpcParam*) -> NpcJointLookAtController*

auto tryCreateAndAppendNpcJointLookAtController(al::LiveActor*, const TalkNpcParam*) -> NpcJointLookAtController*

auto tryCreateAndAppendNpcJointLookAtController(al::LiveActor*, const TalkNpcParam*, f32) -> NpcJointLookAtController*

void setPlayerEyeSensorHitHolder(NpcJointLookAtController*, const PlayerEyeSensorHitHolder*)

auto getNpcJointLookAtControlJointNum(const TalkNpcParam*) -> s32

void updateNpcJointLookAtController(NpcJointLookAtController*)

void cancelUpdateNpcJointLookAtController(NpcJointLookAtController*)

void updateNpcJointLookAtControllerLookAtDistance(NpcJointLookAtController*, f32)

void invalidateNpcJointLookAtController(NpcJointLookAtController*)

void validateNpcJointLookAtController(NpcJointLookAtController*)

void requestLookAtTargetTrans(NpcJointLookAtController*, const sead::Vector3f&)

void initCapWorldNpcTail(al::LiveActor*)

auto tryStartForestManFlowerAnim(al::LiveActor*) -> bool

auto tryUpdateMaterialCodeByFloorCollisionOnArrow(al::LiveActor*) -> bool

void tryAttachConnectorToCollisionTFSV(al::LiveActor*, al::MtxConnector*, sead::Quatf*)

void tryConnectToCollisionTFSV(al::LiveActor*, const al::MtxConnector*, sead::Quatf*)

auto tryGetSubActorCityMayorFace(const al::LiveActor*) -> al::LiveActor*

void syncActionCityMayorFace(al::LiveActor*)

void syncMtsAnimCityMayorFace(al::LiveActor*)

auto isExistFaceAnim(al::LiveActor*, const char*) -> bool

void animateCityMayorFace(al::LiveActor*, const char*, f32)

auto createNpcStateReaction(al::LiveActor*, const TalkNpcParam*, const NpcStateReactionParam*) -> ShellActorStateReaction*

auto isInvalidTrampleSensor(const al::HitSensor*, const TalkNpcParam*) -> bool

auto initEventFlow(al::LiveActor*, const al::ActorInitInfo&, const char*, const char*) -> al::EventFlowExecutor*

void startEventFlow(al::EventFlowExecutor*, const char*)

auto updateEventFlow(al::EventFlowExecutor*) -> bool

void initEventMessageTagDataHolder(al::EventFlowExecutor*, const al::MessageTagDataHolder*)

auto trySendMsgPlayerReflectOrTrample(const al::LiveActor*, al::HitSensor*, al::HitSensor*) -> bool

auto findWallCatchPos(const al::CollisionParts**, sead::Vector3f*, sead::Vector3f*, const al::LiveActor*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32, f32, f32, f32, f32, f32, f32) -> bool

auto findGrabCeilPosNoWallHit(const al::CollisionParts**, sead::Vector3f*, sead::Vector3f*, sead::Vector3f*, const al::LiveActor*, const sead::Vector3f&, const sead::Vector3f&, f32, f32, f32) -> bool

auto findGrabCeilPosWallHit(const al::CollisionParts**, sead::Vector3f*, sead::Vector3f*, sead::Vector3f*, const al::LiveActor*, const sead::Vector3f&, const sead::Vector3f&, f32, f32, f32) -> bool

void calcOffsetAllRoot(sead::Vector3f* offset, const PlayerModelHolder* model)

auto convergeOnGroundCount(s32*, const al::LiveActor*, const IUsePlayerCollision*, s32, s32) -> bool

auto isOnGroundRunAngle(const al::LiveActor*, const IUsePlayerCollision*, const PlayerConst*) -> bool

void startHitReactionHipDropLand(al::LiveActor*, bool)

void waitGround(al::LiveActor*, const IUsePlayerCollision*, f32, f32, f32, f32)

void slerpUpFront(al::LiveActor*, const sead::Vector3f&, const sead::Vector3f&, f32, f32)

auto calcSlideDir(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&) -> bool

void moveDivingJump(al::LiveActor*, const sead::Vector3f&, f32, f32, f32, f32, f32, f32, f32, f32)

void sendPlayerCollisionTouchMsg(const al::LiveActor*, al::HitSensor*, const IUsePlayerCollision*)

auto getGroundHeight(const IUsePlayerHeightCheck*) -> f32

auto getCollidedWallPos(const IUsePlayerCollision*) -> const sead::Vector3f&

auto getCollidedWallNormal(const IUsePlayerCollision*) -> const sead::Vector3f&

auto getCollidedWallCollisionParts(const IUsePlayerCollision*) -> const al::CollisionParts*

auto getCollidedGroundPos(const IUsePlayerCollision*) -> const sead::Vector3f&

auto getCollidedGroundNormal(const IUsePlayerCollision*) -> const sead::Vector3f&

auto getCollidedGroundCollisionParts(const IUsePlayerCollision*) -> const al::CollisionParts*

auto getCollidedCeilingPos(const IUsePlayerCollision*) -> const sead::Vector3f&

auto getCollidedCeilingNormal(const IUsePlayerCollision*) -> const sead::Vector3f&

auto getCollidedCeilingCollisionParts(const IUsePlayerCollision*) -> const al::CollisionParts*

auto isCollidedGround(const IUsePlayerCollision*) -> bool

auto isCollidedGroundRunAngle(const al::LiveActor*, const IUsePlayerCollision*, const PlayerConst*) -> bool

auto isOnGroundSlopeSlideStart(const al::LiveActor*, const IUsePlayerCollision*, const PlayerConst*) -> bool

auto isOnGroundForceSlideCode(const al::LiveActor*, const IUsePlayerCollision*, const PlayerConst*) -> bool

auto isOnGroundForceRollingCode(const al::LiveActor*, const IUsePlayerCollision*) -> bool

auto isOnGroundLessAngle(const al::LiveActor*, const IUsePlayerCollision*, f32) -> bool

auto isPlayerOnGround(const al::LiveActor*) -> bool

auto isOnGround(const al::LiveActor*, const IUsePlayerCollision*) -> bool

auto isJustLand(const IUsePlayerCollision*) -> bool

void calcGroundNormalOrGravityDir(sead::Vector3f*, const al::LiveActor*, const IUsePlayerCollision*)

auto isCollisionCodeSandSink(const IUsePlayerCollision*) -> bool

auto isCollidedWall(const IUsePlayerCollision*) -> bool

auto isCollidedCeiling(const IUsePlayerCollision*) -> bool

auto isActionCodeNoWallGrab(const IUsePlayerCollision*) -> bool

auto isActionCodeNoActionWall(const IUsePlayerCollision*) -> bool

auto isCollisionCodeGrabCeilAny(const IUsePlayerCollision*) -> bool

auto isCollisionCodeGrabCeilWall(const IUsePlayerCollision*) -> bool

auto isCollisionCodeGrabCeilCeiling(const IUsePlayerCollision*) -> bool

auto isCollisionCodeGrabCeilGrround(const IUsePlayerCollision*) -> bool

void setColliderFilterCollisionParts(IUsePlayerCollision*, const al::CollisionPartsFilterBase*)

auto reboundVelocityFromCollision(al::LiveActor*, const IUsePlayerCollision*, f32, f32, f32) -> bool

auto tryGetCollidedCeilingSensor(const IUsePlayerCollision*) -> al::HitSensor*

auto isOnGroundSlopeSlideEnd(const al::LiveActor*, const IUsePlayerCollision*, const PlayerConst*) -> bool

auto isAutoRunOnGroundSkateCode(const al::LiveActor*, const IUsePlayerCollision*, f32) -> bool

auto startPuppet(al::HitSensor* actorHitSensor, al::HitSensor* playerHitSensor) -> IUsePlayerPuppet*

void endBindAndPuppetNull(IUsePlayerPuppet** playerPuppet)

void endBindOnGroundAndPuppetNull(IUsePlayerPuppet** playerPuppet)

void endBindJumpAndPuppetNull(IUsePlayerPuppet** playerPuppet, const sead::Vector3f& endTrans, s32 timeBeforeEnd)

void endBindWallJumpAndPuppetNull(IUsePlayerPuppet** playerPuppet, const sead::Vector3f& endTrans, s32 timeBeforeEnd)

void endBindCapThrow(IUsePlayerPuppet** playerPuppet)

auto tryReceiveBindCancelMsgAndPuppetNull(IUsePlayerPuppet** playerPuppet, const al::SensorMsg* msg) -> bool

void setPuppetTrans(IUsePlayerPuppet* playerPuppet, const sead::Vector3f& trans)

void setPuppetVelocity(IUsePlayerPuppet* playerPuppet, const sead::Vector3f& velocity)

void setPuppetFront(IUsePlayerPuppet* playerPuppet, const sead::Vector3f& front)

void calcPuppetUp(sead::Vector3f* up, const IUsePlayerPuppet* playerPuppet)

void setPuppetUp(IUsePlayerPuppet* playerPuppet, const sead::Vector3f& up)

void calcPuppetFront(sead::Vector3f* front, const IUsePlayerPuppet* playerPuppet)

void setPuppetQuat(IUsePlayerPuppet* playerPuppet, const sead::Quatf& quat)

void resetPuppetPosition(IUsePlayerPuppet* playerPuppet, const sead::Vector3f& trans)

void addPuppetVelocityFall(IUsePlayerPuppet* playerPuppet)

auto getPuppetGravity(const IUsePlayerPuppet* playerPuppet) -> const sead::Vector3f&

auto getPuppetVelocity(const IUsePlayerPuppet* playerPuppet) -> const sead::Vector3f&

auto getPuppetTrans(const IUsePlayerPuppet* playerPuppet) -> const sead::Vector3f&

void calcPuppetQuat(sead::Quatf* quat, const IUsePlayerPuppet* playerPuppet)

void startPuppetAction(IUsePlayerPuppet* playerPuppet, const char* action)

auto isPuppetActionEnd(const IUsePlayerPuppet* playerPuppet) -> bool

auto isPuppetActionPlaying(const IUsePlayerPuppet* playerPuppet, const char* action) -> bool

void setPuppetAnimRate(IUsePlayerPuppet* playerPuppet, f32 animRate)

void setPuppetAnimBlendWeight(IUsePlayerPuppet* playerPuppet, f32 weight1, f32 weight2, f32 weight3, f32 weight4, f32 weight5, f32 weight6)

auto getPuppetAnimFrameMax(const IUsePlayerPuppet* playerPuppet) -> f32

void startPuppetHitReactionLand(IUsePlayerPuppet* playerPuppet)

void hidePuppet(IUsePlayerPuppet* playerPuppet)

void showPuppet(IUsePlayerPuppet* playerPuppet)

auto isPuppetHidden(const IUsePlayerPuppet* playerPuppet) -> bool

void syncPuppetVisibility(al::LiveActor* actor, const IUsePlayerPuppet* playerPuppet)

void hidePuppetSilhouette(IUsePlayerPuppet* playerPuppet)

void showPuppetSilhouette(IUsePlayerPuppet* playerPuppet)

void hidePuppetShadow(IUsePlayerPuppet* playerPuppet)

void showPuppetShadow(IUsePlayerPuppet* playerPuppet)

void validatePuppetSensor(IUsePlayerPuppet* playerPuppet)

void invalidatePuppetSensor(IUsePlayerPuppet* playerPuppet)

void invalidatePuppetCollider(IUsePlayerPuppet* playerPuppet)

auto isCollidedPuppetGround(IUsePlayerPuppet* playerPuppet) -> bool

auto getCollidedPuppetGroundNormal(IUsePlayerPuppet* playerPuppet) -> const sead::Vector3f&

void validatePuppetCollider(IUsePlayerPuppet* playerPuppet)

void requestDamage(IUsePlayerPuppet* playerPuppet)

void clearStainEffect(IUsePlayerPuppet* playerPuppet)

void copyPuppetDitherAlpha(IUsePlayerPuppet* playerPuppet, const al::LiveActor* actor)

void validatePuppetLookAt(IUsePlayerPuppet* playerPuppet)

void invalidatePuppetLookAt(IUsePlayerPuppet* playerPuppet)

void validatePuppetForceLookAt(IUsePlayerPuppet* playerPuppet, const sead::Vector3f& lookAt)

void invalidatePuppetForceLookAt(IUsePlayerPuppet* playerPuppet)

void validatePuppetSeparateMode(IUsePlayerPuppet* playerPuppet)

void invalidatePuppetSeparateMode(IUsePlayerPuppet* playerPuppet)

void validatePuppetReceivePush(IUsePlayerPuppet* playerPuppet)

void invalidatePuppetReceivePush(IUsePlayerPuppet* playerPuppet)

void forcePutOnPuppetCap(IUsePlayerPuppet* playerPuppet)

void forcePutOnPuppetCapWithEffect(IUsePlayerPuppet* playerPuppet)

void setForceRunAfterEndBind(IUsePlayerPuppet* playerPuppet, s32, f32)

void validateRecoveryArea(IUsePlayerPuppet* playerPuppet)

void invalidateRecoveryArea(IUsePlayerPuppet* playerPuppet)

void validateGuideArrow(IUsePlayerPuppet* playerPuppet)

void invalidateGuideArrow(IUsePlayerPuppet* playerPuppet)

void validateWaterSurfaceShadow(IUsePlayerPuppet* playerPuppet)

void invalidateWaterSurfaceShadow(IUsePlayerPuppet* playerPuppet)

auto isPuppetInputCapThrow(const IUsePlayerPuppet* playerPuppet) -> bool

auto isPuppetInputSwing(const IUsePlayerPuppet* playerPuppet) -> bool

auto initBindKeepDemoInfo() -> BindKeepDemoInfo*

auto isActiveBindKeepDemo(const BindKeepDemoInfo* bindKeepDemoInfo) -> bool

auto tryStartBindKeepDemo(BindKeepDemoInfo* bindKeepDemoInfo, const al::SensorMsg* msg, const IUsePlayerPuppet* playerPuppet) -> bool

auto tryEndBindKeepDemo(BindKeepDemoInfo* bindKeepDemoInfo, const al::SensorMsg* msg, IUsePlayerPuppet* playerPuppet) -> bool

auto isPuppetTrigJumpButton(const IUsePlayerPuppet* playerPuppet) -> bool

auto isPuppetHoldJumpButton(const IUsePlayerPuppet* playerPuppet) -> bool

auto isPuppetTrigActionButton(const IUsePlayerPuppet* playerPuppet) -> bool

auto isPuppetHoldActionButton(const IUsePlayerPuppet* playerPuppet) -> bool

auto isPuppetTriggerAnyButton(const IUsePlayerPuppet* playerPuppet) -> bool

auto isPuppetHoldAnyButton(const IUsePlayerPuppet* playerPuppet) -> bool

auto isPuppetMoveStickOn(const IUsePlayerPuppet* playerPuppet) -> bool

auto isPuppetStartWorldWarp(const IUsePlayerPuppet* playerPuppet) -> bool

auto isPuppetCancelWorldWarp(const IUsePlayerPuppet* playerPuppet) -> bool

auto getPuppetMoveStick(const IUsePlayerPuppet* playerPuppet) -> const sead::Vector2f&

auto isTriggerGetOff(const IUsePlayerPuppet* playerPuppet) -> bool

auto getPuppetPoseRotZDegreeLeft(const IUsePlayerPuppet* playerPuppet) -> f32

auto getPuppetPoseRotZDegreeRight(const IUsePlayerPuppet* playerPuppet) -> f32

void requestUpdateSafetyPoint(IUsePlayerPuppet* playerPuppet, const al::LiveActor* actor, const IUsePlayerCollision* playerCollision)

void requestForceSafetyPoint(IUsePlayerPuppet* playerPuppet, const sead::Vector3f& recoveryTrans, const sead::Vector3f& recoveryNormal)

void initPlayerActorInfo(PlayerActorBase*, const PlayerInitInfo&)

auto getInitPlayerModelName(const PlayerInitInfo&) -> const char*

auto isNeedCreateNoseNeedle(const PlayerInitInfo&) -> bool

auto isClosetScenePlayer(const PlayerInitInfo&) -> bool

auto getGamePadSystem(const PlayerInitInfo&) -> al::GamePadSystem*

auto getInitCapTypeName(const PlayerInitInfo&) -> const char*

auto createPlayerSklRetargettingInfo(al::LiveActor*, const sead::Vector3f&) -> al::SklAnimRetargettingInfo*

auto getPlayerPos(const al::LiveActor*) -> const sead::Vector3f&

auto getPlayerHeadPos(const al::LiveActor*) -> const sead::Vector3f&

auto getPlayerBodyPos(const al::LiveActor*) -> const sead::Vector3f&

void calcPlayerSideDir(sead::Vector3f*, const al::LiveActor*)

void calcPlayerUpDir(sead::Vector3f*, const al::LiveActor*)

void calcPlayerFrontDir(sead::Vector3f*, const al::LiveActor*)

void calcPlayerGroundPoseUp(sead::Vector3f*, const al::LiveActor*)

auto isNearPlayerH(const al::LiveActor*, f32) -> bool

void calcPlayerFollowLayoutWorldPos(sead::Vector3f*, const al::LiveActor*)

auto isPlayerHack(const al::LiveActor*) -> bool

auto isPlayerHackGroupUseCameraStick(const al::LiveActor*) -> bool

auto tryCalcPlayerCeilingSpace(f32*, const al::LiveActor*, f32, f32) -> bool

auto tryCalcKidsGuideCeilingSpace(f32*, const al::LiveActor*, f32, f32) -> bool

auto getPlayerVelocity(const al::LiveActor*) -> const sead::Vector3f&

auto tryCalcPlayerModelHeadJointPos(sead::Vector3f*, const al::LiveActor*) -> bool

auto tryCalcPlayerModelHeadJointUp(sead::Vector3f*, const al::LiveActor*) -> bool

auto tryCalcPlayerModelHeadJointFront(sead::Vector3f*, const al::LiveActor*) -> bool

auto tryCalcPlayerModelHeadJointSide(sead::Vector3f*, const al::LiveActor*) -> bool

auto tryCalcPlayerModelNoseJointMtx(sead::Matrix34f*, const al::LiveActor*) -> bool

auto isPlayerDamageStopDemo(const al::LiveActor*) -> bool

auto isPlayerHackType(const al::LiveActor*, s32) -> bool

auto isPlayerHackRigidBody(const al::LiveActor*) -> bool

auto isPlayerHackJugemFishing(const al::LiveActor*) -> bool

auto isPlayerHackKuriboAny(const al::LiveActor*) -> bool

auto isPlayerHackKuribo(const al::LiveActor*) -> bool

auto isPlayerHackKuriboWing(const al::LiveActor*) -> bool

auto isPlayerHackStatueMario(const al::LiveActor*) -> bool

auto isPlayerHackEnemy(const al::LiveActor*) -> bool

auto isPlayerHackTrilemmaRock(const al::LiveActor*) -> bool

auto isPlayerHackTrilemmaPaper(const al::LiveActor*) -> bool

auto isPlayerHackTrilemmaScissors(const al::LiveActor*) -> bool

auto isPlayerHackElectricWire(const al::LiveActor*) -> bool

auto isPlayerHackTRex(const al::LiveActor*) -> bool

auto isPlayerHackFukankun(const al::LiveActor*) -> bool

auto isPlayerHackHosui(const al::LiveActor*) -> bool

auto isPlayerHackYoshi(const al::LiveActor*) -> bool

auto isPlayerHackYukimaru(const al::LiveActor*) -> bool

auto isPlayerHackHammerBros(const al::LiveActor*) -> bool

auto isPlayerHackBazookaElectric(const al::LiveActor*) -> bool

auto isPlayerHackBubble(const al::LiveActor*) -> bool

auto isPlayerHackTank(const al::LiveActor*) -> bool

auto isPlayerHackTsukkun(const al::LiveActor*) -> bool

auto isPlayerHackPukupuku(const al::LiveActor*) -> bool

auto isPlayerHackPukupukuAll(const al::LiveActor*) -> bool

auto isPlayerHackRadiconNpc(const al::LiveActor*) -> bool

auto isPlayerHackSenobi(const al::LiveActor*) -> bool

auto isPlayerHackKakku(const al::LiveActor*) -> bool

auto isPlayerHackGroupTalkScare(const al::LiveActor*) -> bool

auto isPlayerHackNoSeparateCameraInput(const al::LiveActor*) -> bool

auto isPlayerEnableToSeeOddSpace(const al::LiveActor*) -> bool

auto isPlayerMini(const al::LiveActor*) -> bool

auto isPlayer3D(const al::LiveActor*) -> bool

auto isPlayer2D(const al::LiveActor*) -> bool

auto isPlayerSquat(const al::LiveActor*) -> bool

auto isPlayerInWater(const al::LiveActor*) -> bool

auto isPlayerPoleClimb(const al::LiveActor*) -> bool

auto isPlayerWallCatch(const al::LiveActor*) -> bool

auto isPlayerCameraSubjective(const al::LiveActor*) -> bool

auto isPlayerEnableTalkGround(const al::LiveActor*) -> bool

auto isPlayerEnableTalkSwim(const al::LiveActor*) -> bool

auto isPlayerBinding(const al::LiveActor*) -> bool

auto isPlayerEquipSomething(const al::LiveActor*) -> bool

auto isPlayerEquipRocketFlower(const al::LiveActor*) -> bool

auto isPlayerEquipNoSeparateAction(const al::LiveActor*) -> bool

auto isPlayerCarrySomething(const al::LiveActor*) -> bool

auto isPlayerNoInput(const al::LiveActor*) -> bool

auto isPlayerEnableShowTutorialInput(const al::LiveActor*) -> bool

auto isPlayerSafetyPointRecovery(const al::LiveActor*) -> bool

auto isPlayerPlayingSwitchOnAnim(const al::LiveActor*) -> bool

auto isPlayerEquipNoSeparateTutorial(const al::LiveActor*) -> bool

auto isPlayerWaitSleep(const al::LiveActor*) -> bool

auto isPlayerAboveSeparateCapGuideArrow(const al::LiveActor*) -> bool

auto isPlayerInvalidateGuideArrow(const al::LiveActor*) -> bool

auto isPlayerInvisibleCap(const al::LiveActor*) -> bool

auto isPlayerEnablePeachAmiibo(const al::LiveActor*) -> bool

auto isPlayerActiveMarioAmiiboInvincible(const al::LiveActor*) -> bool

auto isPlayerCollidedGround(const al::LiveActor*) -> bool

auto isPlayerCollidedCeiling(const al::LiveActor*) -> bool

auto isPlayerOnActor(const al::LiveActor*) -> bool

auto isPlayerOnChairActor(const al::LiveActor*) -> bool

auto isPlayerOnBedActor(const al::LiveActor*) -> bool

auto isPlayerFaceToTarget(const al::LiveActor*, const sead::Vector3f&) -> bool

auto isPlayerFaceToTarget(const al::LiveActor*) -> bool

auto isPlayerFaceToTargetInRange(const al::LiveActor*, const sead::Vector3f&, f32) -> bool

auto isPlayerFaceToTargetInRange(const al::LiveActor*, f32) -> bool

auto tryGetFlyingCapPos(sead::Vector3f*, const al::LiveActor*) -> bool

auto tryGetFlyingCapVelocity(sead::Vector3f*, const al::LiveActor*) -> bool

auto isEnableReceiveCapStartLockOnAngle(const al::LiveActor*, const al::HitSensor*) -> bool

auto isEquipCapCatched(const al::LiveActor*) -> bool

auto getFlyingCapThrowSpeedMax(const al::LiveActor*) -> f32

auto isPlayerCapSpinOrFlying(const al::LiveActor*) -> bool

auto isPlayerCapFlying(const al::LiveActor*) -> bool

auto isPlayerCapSeparateThrow(const al::LiveActor*) -> bool

auto isEmptyPlayerOxygen(const al::LiveActor*) -> bool

void recoveryPlayerOxygen(const al::LiveActor*)

void requestBindPlayer(const al::LiveActor*, al::HitSensor*)

void sendMsgBreakFloorToPlayer(const al::LiveActor*)

void requestStageStartHack(const al::LiveActor*, al::HitSensor*, const CapTargetInfo*, al::LiveActor*)

auto isEnableOpenMap(const al::LiveActor*) -> bool

void syncPlayerModelAlpha(al::LiveActor*)

auto getPlayerShadowDropLength(const al::LiveActor*) -> f32

auto isExistLabelInPlayerHackSystemMstxt(const al::LiveActor*, const al::IUseMessageSystem*, const char*, const char*) -> bool

auto getPlayerHackSystemMessageString(const al::LiveActor*, const al::IUseMessageSystem*, const char*, const char*) -> const char16*

void getPlayerHackTutorialMoviePath(al::StringTmp<64>*, const al::LiveActor*, const char*)

void calcPlayerAmiiboPeachAppearBasePos(sead::Vector3f*, const al::LiveActor*)

auto isPlayerInputHoldBalloonSet(const al::LiveActor*) -> bool

auto isPlayerInputHoldSquat(const al::LiveActor*) -> bool

auto isPlayerInputHoldCapKeepLockOn(const al::LiveActor*) -> bool

auto isPlayerInputHoldCarryAction(const al::LiveActor*) -> bool

auto isPlayerInputHoldEnterUpperDokan2D(const al::LiveActor*) -> bool

auto isPlayerInputHoldEnterSideDokan2D(const al::LiveActor*, const sead::Vector3f&) -> bool

auto isPlayerInputTriggerStartTalk(const al::LiveActor*) -> bool

auto isPlayerInputTriggerRide(const al::LiveActor*) -> bool

auto isPlayerInputTriggerSeparateCapJangoHelp(const al::LiveActor*) -> bool

auto tryGetPlayerInputWallAlongWallNormal(sead::Vector3f*, const al::LiveActor*) -> bool

void calcPlayerHoldPos(sead::Vector3f*, const al::HitSensor*)

void calcPlayerHoldMtx(sead::Matrix34f*, const al::HitSensor*)

void setPlayerHoldJointAngle(const al::HitSensor*, const sead::Vector3f&)

void updatePosePlayerHold(al::LiveActor*, const al::HitSensor*)

void updatePosePlayerHoldAddOffset(al::LiveActor*, const al::HitSensor*, const sead::Vector3f&)

auto calcPlayerGuideOffsetY(const al::LiveActor*) -> f32

auto isEnablePlayerHeadGuide(const al::LiveActor*) -> bool

void calcPlayerGuidePos(sead::Vector3f*, const al::LiveActor*)

void calcPlayerGuidePos(sead::Vector3f*, const al::LiveActor*, f32)

auto trySavePrepoCompleteMainScenario(s32, s32, s64, s64, s64) -> bool

auto trySavePrepoStartStage(const char*, const sead::Vector3f&, s64, s64, s64) -> bool

auto trySavePrepoExitStage(const char*, const sead::Vector3f&, s64, s64, s64) -> bool

auto trySavePrepoMissEvent(const char*, const sead::Vector3f&, s64, s64, s64) -> bool

auto trySavePrepoShineGetEvent(const char*, s32, s32, s32, s64, s64, s64) -> bool

auto trySavePrepoReceiveAchievement(const char* s32, s64, s64, s64) -> bool

auto trySavePrepoAchievementProgress(GameDataHolderAccessor, s64, s64, s64) -> bool

auto trySavePrepoGetCapEvent(const char*, s32, s64, s64, s64) -> bool

auto trySavePrepoGetClothEvent(const char*, s32, s64, s64, s64) -> bool

auto trySavePrepoGetGiftEvent(const char*, s32, s64, s64, s64) -> bool

auto trySavePrepoGetStickerEvent(const char*, s32, s64, s64, s64) -> bool

auto trySavePrepoChangeCapEvent(const char*, s64, s64, s64) -> bool

auto trySavePrepoChangeClothEvent(const char*, s64, s64, s64) -> bool

auto trySavePrepoFirstHackEvent(const char*, s32, s64, s64, s64) -> bool

auto trySavePrepoGetCollectBgmEvent(const char*, const char*, bool, s32, s64, s64, s64) -> bool

auto trySavePrepoSettingsState(bool, const char*, const GameConfigData&, s64, s64) -> bool

auto trySavePrepoSeparatePlayMode(bool, s64, s64, s64) -> bool

auto sendMsgAckCheckpoint(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgAckGetShine(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgAckLifeUp(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgAckLifeMaxUp(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgAskRailCollision(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBreakPartsBreak(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBirdFlyAway(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCameraAngleElevationResetFast(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgChorobonAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgConductLightning(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgDamageBallAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgDamageBallBodyAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgDonsukeAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgDonsukeGroundAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgDonsukePush(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgDragonAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgEatExplosion(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgElectricWireNoLimitDistance(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgEnemyAttack2D(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgEnemyAttack3D(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgEnemyAttackDash(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHackAttackFire(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgEnemyAttackFireCollision(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgEnemyAttackPoison(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgEnemyAttackTRex(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHackAttackPoison(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgConfirmPaintObj(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgConfirmPaintObjForSeed(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPaintAttackPoison(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgEnemyKick(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgRabbitKick(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgFishingAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgFishingCancel(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgFishingFishApproach(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgFishingFishFloatTouch(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgFishingItemGet(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgFishingLineTouch(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgFishingStart(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgFishingUpImmediatelyPrepare(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgFireBrosFireBallCollide(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgFireSwitchFire(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgFrogHackTrample(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgGhostRecordStart(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgGhostRecordEnd(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgGhostPlay(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgGhostStop(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgGiantWanderBossAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgGiantWanderBossBulletAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgGiantWanderBossBulletPush(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgGhostReverse(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgGhostCancel(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgGrowFlowerSeedDisablePush(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgGrowFlowerSeedNear(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgGrowPlantPush(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgGrowerAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgGrowerWallAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgGunetterAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgGunetterBodyTouch(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHammerAttackDown(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHammerAttackSide(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHammerAttackSideCollide(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgItemAmiiboKoopa(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgIsExistPukupuku(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgJangoAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgJangoRemoveCap(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKakkuKick(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKillByBossBattleDemo(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKillByHackFirstDemo(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKillByHomeDemo(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgEndHomeDemo(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKillByMoonRockDemo(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKillByShineGet(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKillBySwitchTimer(al::LiveActor*) -> bool

auto sendMsgKoopaBindStart(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKoopaCapPlayerFocusTarget(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKoopaCapPunchFinishL(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKoopaCapPunchFinishR(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKoopaCapPunchInvincibleL(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKoopaCapPunchInvincibleR(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKoopaCapPunchKnockBackL(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKoopaCapPunchKnockBackR(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKoopaCapPunchL(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKoopaCapPunchR(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKoopaCapSpinAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKoopaCatchKoopaCap(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKoopaDashPunchAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKoopaFire2D(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKoopaFireBallAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKoopaHackDamage(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKoopaHackPunch(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKoopaHackPunchCollide(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKoopaHackTrample(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKoopaInvalidHackPunchFaceToCollision(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKoopaRingBeamInvalidTouch(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKoopaTailAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKoopaTouchFloor(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKouraAttack2D(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKouraItemGet2D(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgLaunchBlow(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgMeganeAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgMeganeHackTrample(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgMofumofuBulletUnexplosion(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgMoonBasementAttackMeteor(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgMoonBasementBreakShockwaveMeteor(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgMoonBasementRockSyncClippingRegist(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgMoonBasementRockSyncClippingInvalidate(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgMoonBasementRockSyncClippingValidate(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgAttachCactusNeedle(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCactusNeedleAttack(al::HitSensor* source, al::HitSensor* target, al::ComboCounter*) -> bool

auto sendMsgCactusNeedleAttackStrong(al::HitSensor* source, al::HitSensor* target, al::ComboCounter*) -> bool

auto sendMsgPlayerBallToss(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerCarryCameraSubjectiveStart(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerCarryCameraSubjectiveEnd(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerCarryShineGetStart(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerCarryShineGetEnd(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerCapCatch(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerCapHipDrop(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerCapPush(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerCapRecovery(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerCapTouchJump(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerCapTrample(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerCoinDashGet(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerEyePriorityTarget(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerDisregardHomingAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerDisregardTargetMarker(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerEquipKoopaCap(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerFireBallAttack2D(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerFireBallAttack3D(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerHipDropDemoTrigger(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerHipDropHipDropSwitch(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerItemGet2D(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerJumpTakeOffFloor(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerObjectWallHit(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerObjLeapFrog(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerPenguinAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerPenguinAttackReflect(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerPoleClimbKeep(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerPoleClimbReaction(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerRabbitGet(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerRollingObjHit(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerRollingWallHitDown(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerRollingWallHitMove(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerStartGrabCeil(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerStartWallJump(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerEndGrabCeil(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerSwordAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerTouchFloorJumpCode(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerTrample2D(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerUpperPunch2D(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerObjUpperPunch2D(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPukupukuDash(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPukupukuKiss(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPukupukuRollingAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPush2D(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPushToFish(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPushToMotorcycle(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPushToPlayer(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgRadishAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgRadishReflect(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgRequestChangeKinokoSuper(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgRequestChangeFireFlower(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgRequestPlayerSandMoon(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgRequestPlayerSnow(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgRequestPlayerWet(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgStartHack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgSunshineAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCancelHack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCancelHackArea(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCancelHackByDokan(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPackunEatStart(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHackAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHackAttackKick(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHackAttackMapObj(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHackDeathAreaSelfCheck(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHackDemoEnd(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHackDemoStart(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHackInvalidEscape(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHackInvalidEscapeNoReaction(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHackMarioCheckpointFlagWarp(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHackMarioDead(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHackMarioDemo(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHackMarioInWater(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHackMoveRockForestPush(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHackSelfCeilingCheckMiss(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHackSyncDamageVisibility(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgWeaponItemGet(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCapAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCapAttackCollide(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCapAttackStayRolling(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCapAttackStayRollingCollide(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCapAttackRailMove(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCapGiantAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCapReflect(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCapReflectCollide(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCapStartLockOn(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCapKeepLockOn(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCapCancelLockOn(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCapHipDrop(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCapObjHipDrop(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCapObjHipDropReflect(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCapIgnoreCancelLockOn(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCapIgnoreCancelMissReaction(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCapIgnoreCollisionCheck(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCapItemGet(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCapTrampolineAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCatchBombThrough(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCheckCarObstacle(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCheckIsCardboardBox(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBullHackAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBullEnemyAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgEnemyAttackStrong(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgEnemyObjBreak(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgWhipAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgNoLimitTouchJump(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgNoticePlayerDamage(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgStatueDrop(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgStatueTrampleReflect(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgStatuePush(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgStatueSnap(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHitGrowFlowerPot(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHitGrowPlantPot(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgImplantGrowFlowerSeed(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgIcicleAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgIgnoreMirrorWarp(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgIgnoredByRunawayNpc(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgIgnorePushMotorcycle(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgSandSharkAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgSeedAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgSeedAttackBig(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgSeedAttackHold(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgSeedItemGet(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgSeedReflect(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgSenobiTrample(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgSenobiCancelStretch(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgSenobiPunchBlockTransparent(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgShibakenApproach(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgShibakenKick(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHackUpperPunch(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHackObjUpperPunch(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgShineGet(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgShineGet2D(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgSpherePush(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, f32) -> bool

auto sendMsgSphinxJumpAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgSphinxQuizRouteKill(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgSphinxRideAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgSphinxRideAttackReflect(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPechoSpot(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBelowObjBroken(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBindCollidedGround(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBindKeepDemoStart(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBindKeepDemoExecute(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBindKeepDemoEnd(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBindRecoveryLife(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgMayorItemReflect(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgMayorItemCollide(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBlowObjAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBlowObjAttackReflect(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgConfirmFrailBox(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgConfirmBrokenFrailBox(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgTankLookOn(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgTankKickHack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgTankKickEnemy(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgTankBullet(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgTankBulletNoReaction(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgTimerAthleticDemoStart(al::LiveActor*) -> bool

auto sendMsgRideOnStart(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgRideOnEnd(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgRideOnRelease(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHipDropTransformTransform(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHipDropTransformReverse(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHipDropTransformingUp(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHipDropTransformingDown(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHipDropTransformingFinish(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgClearFire(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgCollectAnimalTouchCollide(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBossKnuckleCounter(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBossKnuckleFallAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBossKnuckleHackAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBossKnuckleKillerAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBossKnuckleIceConflict(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBossKnuckleIceFallToMummy(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgSkaterAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgEnableInSaucePan(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgEnableMapCheckPointWarp(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgStartInSaucePan(al::HitSensor* source, al::HitSensor* target, bool) -> bool

auto sendMsgEndInSaucePan(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgLineDancerLink(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgLongPushSensorHit(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgLongPushBoxHit(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgGoldHammerAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgTrashBoxIn(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgTouchDoorDrumn(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKuribo2DTouch(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKuriboCollisionDamage(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKuriboCollisionKill(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKuriboFlick(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKuriboTowerOn(al::HitSensor* source, al::HitSensor* target, u32) -> bool

auto sendMsgPartyPopperSoundAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgYokinBallAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgYoshiDirectEat(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgYoshiTongueAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgYoshiTongueEatBind(al::HitSensor* source, al::HitSensor* target, f32*, f32*, f32*) -> bool

auto sendMsgYoshiTongueEatBindCancel(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgYoshiTongueEatBindFinish(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgYoshiTongueEatHomingTarget(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgYukimaruPush(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPunchMachinePunchStraight(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPunchMachinePunchHook(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPunchMachinePunchUpper(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgMorningStarWarpStart(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgMorningStarWarpEnd(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgGemyAim(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHammerBrosHammerEnemyAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHammerBrosHammerHackAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHammerBrosHammerSearch(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHackBrosContact(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgMotorcycleAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgMotorcycleCollideParkingLot(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgMotorcycleDashAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgMotorcycleDashCollide(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgWanwanEnemyAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgWanwanPush(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgWanwanReboundAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgWanwanBlockAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgWanwanHoleIn(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgWaterRoadIn(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgWaterRoadNear(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBreedaSlap(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBreedaPush(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgGamaneBullet(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgGamaneBulletThrough(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgGamaneBulletForCoinFlower(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgVolleyballNpcScareByEnemy(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgRocketFlowerExtension(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgWanderBossCameraRange(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKuriboGirlAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKuriboGirlLove(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKuriboTop(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgTRexAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgTRexAttackCollideBody(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgTRexAttackCollideHead(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgTRexDashAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgTRexScrollPartsBreakWith(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgTsukkunNoTrace(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgTouchFireDrum2D(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPropellerAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgTankExplosion(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgTankHackTrample(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgUtsuboAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKillerAttackNoExplode(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKillerMagnumAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgKillerMagnumHackAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgGabuzouAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgStackerRollingAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgStackerCapBoostAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgIgnoreIgnitionBomb(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgExplosionReflectBomb(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgGolemStampPress(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgSwitchOnWithSaveRequest(al::LiveActor*, SaveObjInfo*) -> bool

auto sendMsgWanwanReboundAttackToCollided(const al::LiveActor*, al::HitSensor*) -> bool

auto sendMsgWanwanBlockAttackToCollided(const al::LiveActor*, al::HitSensor*) -> bool

auto sendMsgDigPointSmell(al::HitSensor* source, al::HitSensor* target, DigPoint*) -> bool

auto sendMsgMofumofuBodyChainExplode(al::HitSensor* source, al::HitSensor* target, s32) -> bool

auto sendMsgMoonBasementRockThroughCollision(al::HitSensor* source, al::HitSensor* target, bool) -> bool

auto sendMsgFishingWait(al::HitSensor* source, al::HitSensor* target, al::HitSensor*) -> bool

auto sendMsgFishingUpImmediately(al::HitSensor* source, al::HitSensor* target, const sead::Matrix34f&, const sead::Vector3f&, const char*) -> bool

auto sendMsgGunetterPush(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, f32) -> bool

auto sendMsgTestPunch(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, s32, s32) -> bool

auto sendMsgTestPunchStrong(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, s32, s32) -> bool

auto sendMsgPunchGuard(al::HitSensor* source, al::HitSensor* target, s32, s32) -> bool

auto sendMsgTsukkunThrust(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, s32, bool) -> bool

auto sendMsgTsukkunThrustSpin(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, s32, bool) -> bool

auto sendMsgTsukkunThrustReflect(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, s32, bool) -> bool

auto sendMsgTsukkunThrustCollide(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, s32, bool) -> bool

auto sendMsgTsukkunThrustHitReflectCollide(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, s32, bool) -> bool

auto sendMsgTsukkunThrustReflectCollide(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, s32, bool) -> bool

auto sendMsgTsukkunThrustHole(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, const sead::Vector3f&) -> bool

auto sendMsgTsukkunThroughCollide(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgTsukkunHoldCollide(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgTsukkunForceCancelCollide(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgNetworkShootingShot(al::HitSensor* source, al::HitSensor* target, s32) -> bool

auto sendMsgNetworkShootingChargeShot(al::HitSensor* source, al::HitSensor* target, s32) -> bool

auto sendMsgRequestPlayerJumpBreakFloor(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgRequestPlayerJump(al::HitSensor* source, al::HitSensor* target, f32) -> bool

auto sendMsgRequestPlayerTrampleJump(al::HitSensor* source, al::HitSensor* target, f32) -> bool

auto sendMsgRequestPlayerSpinJump(al::HitSensor* source, al::HitSensor* target, f32) -> bool

auto sendMsgRequestSphinxJump(al::HitSensor* source, al::HitSensor* target, f32) -> bool

auto sendMsgIgnoreTouchTarget(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgIgnoreTouchTarget(al::ScreenPointer*, al::ScreenPointTarget*) -> bool

auto sendMsgInitTouchTargetInfo(al::HitSensor* source, al::HitSensor* target, TouchTargetInfo*, const sead::Vector3f*) -> bool

auto sendMsgInitTouchTargetInfo(al::ScreenPointer*, al::ScreenPointTarget*, TouchTargetInfo*, const sead::Vector3f*) -> bool

auto sendMsgCollisionImpulse(al::HitSensor* source, al::HitSensor* target, sead::Vector3f*, const sead::Vector3f&, f32, const sead::Vector3f&, f32) -> bool

auto sendMsgWhipHold(al::HitSensor* source, al::HitSensor* target, WhipTargetInfo*) -> bool

auto sendMsgWhipBind(al::HitSensor* source, al::HitSensor* target, WhipTargetInfo*) -> bool

auto sendMsgWhipThrow(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&) -> bool

auto sendMsgMagnet(al::HitSensor* source, al::HitSensor* target, bool) -> bool

auto sendMsgMagnetBulletAttack(al::HitSensor* source, al::HitSensor* target, f32) -> bool

auto sendMsgDashPanel(al::HitSensor* source, al::HitSensor* target, s32) -> bool

auto sendMsgTrampolineCrackJump(al::HitSensor* source, al::HitSensor* target, f32, f32) -> bool

auto sendMsgCapTouchWall(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, const sead::Vector3f&) -> bool

auto sendMsgCapRethrow(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&) -> bool

auto sendMsgCapRethrowReturnOnly(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&) -> bool

auto sendMsgCapChangeGiant(al::HitSensor* source, al::HitSensor* target, f32, s32) -> bool

auto sendMsgPackunEatCancel(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, const sead::Vector3f&) -> bool

auto sendMsgPackunEatEnd(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, const sead::Vector3f&) -> bool

auto sendMsgPackunEatStartFollow(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f*) -> bool

auto sendMsgFireBlowerAttack(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, const sead::Vector3f&, f32) -> bool

auto sendMsgPaint(al::HitSensor* source, al::HitSensor* target, const sead::Color4u8&, s32, s32) -> bool

auto sendMsgPaintTexture(al::HitSensor* source, al::HitSensor* target, s32, f32, s32) -> bool

auto sendMsgCheckPaintClear(al::HitSensor* source, al::HitSensor* target, const sead::Color4u8&, const sead::Vector3f&, s32) -> bool

auto sendMsgCheckPaintAlpha(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&) -> bool

auto sendMsgByugoBlow(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&) -> bool

auto sendMsgHackDirectStageInit(al::HitSensor* source, al::HitSensor* target, IUsePlayerHack*) -> bool

auto sendMsgObjSnapForce(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&) -> bool

auto sendMsgCapBeamerBeam(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHosuiAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHosuiAttackCollide(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHosuiAttackNoEffect(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHosuiAttackStrong(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHosuiTouch(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHosuiTrample(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHosuiTrampleReflect(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgHosuiTrampleReflectHigh(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBubbleAttack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBubbleAttackToPecho(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBubbleReflectH(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBubbleReflectV(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBubbleWallTouch(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBubbleGroundTouchTrigger(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBubbleLauncherStart(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgSenobiPartsMove(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, f32) -> bool

auto sendMsgStampTo2D(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&) -> bool

auto sendMsgAirExplosion(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&) -> bool

auto sendMsgPushVelocity(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&) -> bool

auto sendMsgGhostRecordStartOk(al::HitSensor* source, al::HitSensor* target, const char*) -> bool

auto sendMsgSandGeyserRaise(al::HitSensor* source, al::HitSensor* target, f32, f32) -> bool

auto sendMsgRaceWait(al::LiveActor*) -> bool

auto sendMsgRaceStart(al::LiveActor*) -> bool

auto sendMsgRaceStop(al::LiveActor*) -> bool

auto sendMsgRaceReturnToCourse(al::LiveActor*, const sead::Vector3f&, const sead::Vector3f&) -> bool

auto sendMsgPlayerLookAtPosition(al::HitSensor* source, al::HitSensor* target, sead::Vector3f*) -> bool

auto sendMsgTargetMarkerPosition(al::HitSensor* source, al::HitSensor* target, sead::Vector3f*) -> bool

auto sendMsgHackBlowJump(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, f32) -> bool

auto sendMsgGolemStampPushV(al::HitSensor* source, al::HitSensor* target, f32) -> bool

auto sendMsgGolemStampPushH(al::HitSensor* source, al::HitSensor* target, f32) -> bool

auto sendMsgRequestPlayerWaitAnimDigPoint(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgEventFlowScareCheck(al::HitSensor* source, al::HitSensor* target, al::EventFlowExecutor*) -> bool

auto sendMsgPlayerItemGetAll(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPlayerItemGetAll2D(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgTRexAttackAll(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgSeedTouch(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, const sead::Vector3f&) -> bool

auto sendMsgSphinxRideAttackTouchThrough(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, const sead::Vector3f&) -> bool

auto sendMsgSphinxRideAttackTouch(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, const sead::Vector3f&) -> bool

auto isMsgAckCheckpoint(const al::SensorMsg*) -> bool

auto isMsgAckGetShine(const al::SensorMsg*) -> bool

auto isMsgAckLifeUp(const al::SensorMsg*) -> bool

auto isMsgAckLifeMaxUp(const al::SensorMsg*) -> bool

auto isMsgAskRailCollision(const al::SensorMsg*) -> bool

auto isMsgAttachCactusNeedle(const al::SensorMsg*) -> bool

auto isMsgAirExplosion(const al::SensorMsg*) -> bool

auto isMsgBelowObjBroken(const al::SensorMsg*) -> bool

auto isMsgBindCollidedGround(const al::SensorMsg*) -> bool

auto isMsgBindKeepDemoStart(const al::SensorMsg*) -> bool

auto isMsgBindKeepDemoExecute(const al::SensorMsg*) -> bool

auto isMsgBindKeepDemoEnd(const al::SensorMsg*) -> bool

auto isMsgBindRecoveryLife(const al::SensorMsg*) -> bool

auto isMsgBirdFlyAway(const al::SensorMsg*) -> bool

auto isMsgBlowObjAttack(const al::SensorMsg*) -> bool

auto isMsgMayorItemCollide(const al::SensorMsg*) -> bool

auto isMsgMayorItemReflect(const al::SensorMsg*) -> bool

auto isMsgBlowObjAttackReflect(const al::SensorMsg*) -> bool

auto isMsgBossKnuckleCounter(const al::SensorMsg*) -> bool

auto isMsgBossKnuckleFallAttack(const al::SensorMsg*) -> bool

auto isMsgBossKnuckleHackAttack(const al::SensorMsg*) -> bool

auto isMsgBossKnuckleIceConflict(const al::SensorMsg*) -> bool

auto isMsgBossKnuckleIceFallToMummy(const al::SensorMsg*) -> bool

auto isMsgBossKnuckleKillerAttack(const al::SensorMsg*) -> bool

auto isMsgBreakPartsBreak(const al::SensorMsg*) -> bool

auto isMsgBreedaSlap(const al::SensorMsg*) -> bool

auto isMsgBreedaPush(const al::SensorMsg*) -> bool

auto isMsgBubbleAttack(const al::SensorMsg*) -> bool

auto isMsgBubbleAttackToPecho(const al::SensorMsg*) -> bool

auto isMsgBubbleLauncherStart(const al::SensorMsg*) -> bool

auto isMsgBubbleReflectH(const al::SensorMsg*) -> bool

auto isMsgBubbleReflectV(const al::SensorMsg*) -> bool

auto isMsgBubbleWallTouch(const al::SensorMsg*) -> bool

auto isMsgBubbleGroundTouchTrigger(const al::SensorMsg*) -> bool

auto isMsgBullAttack(const al::SensorMsg*) -> bool

auto isMsgBullHackAttack(const al::SensorMsg*) -> bool

auto isMsgBullEnemyAttack(const al::SensorMsg*) -> bool

auto isMsgByugoBlow(const al::SensorMsg*) -> bool

auto isMsgCameraAngleElevationResetFast(const al::SensorMsg*) -> bool

auto isMsgCancelHack(const al::SensorMsg*) -> bool

auto isMsgCancelHackArea(const al::SensorMsg*) -> bool

auto isMsgCancelHackByDokan(const al::SensorMsg*) -> bool

auto isMsgCapAttack(const al::SensorMsg*) -> bool

auto isMsgCapAttackCollide(const al::SensorMsg*) -> bool

auto isMsgCapAttackRailMove(const al::SensorMsg*) -> bool

auto isMsgCapAttackStayRolling(const al::SensorMsg*) -> bool

auto isMsgCapAttackStayRollingCollide(const al::SensorMsg*) -> bool

auto isMsgCapBeamerBeam(const al::SensorMsg*) -> bool

auto isMsgCapCancelLockOn(const al::SensorMsg*) -> bool

auto isMsgCapChangeGiant(const al::SensorMsg*) -> bool

auto isMsgCapEnableLockOn(const al::SensorMsg*) -> bool

auto isMsgCapStartLockOn(const al::SensorMsg*) -> bool

auto isMsgCapKeepLockOn(const al::SensorMsg*) -> bool

auto isMsgCapGiantAttack(const al::SensorMsg*) -> bool

auto isMsgCapHipDrop(const al::SensorMsg*) -> bool

auto isMsgCapObjHipDrop(const al::SensorMsg*) -> bool

auto isMsgCapObjHipDropReflect(const al::SensorMsg*) -> bool

auto isMsgCapIgnoreCancelLockOn(const al::SensorMsg*) -> bool

auto isMsgCapIgnoreCancelMissReaction(const al::SensorMsg*) -> bool

auto isMsgCapIgnoreCollisionCheck(const al::SensorMsg*) -> bool

auto isMsgCapItemGet(const al::SensorMsg*) -> bool

auto isMsgCapReflect(const al::SensorMsg*) -> bool

auto isMsgCapReflectCollide(const al::SensorMsg*) -> bool

auto isMsgCapRethrow(const al::SensorMsg*) -> bool

auto isMsgCapTouchWall(const al::SensorMsg*) -> bool

auto isMsgCapTrampolineAttack(const al::SensorMsg*) -> bool

auto isMsgCatchBombThrough(const al::SensorMsg*) -> bool

auto isMsgCheckCarObstacle(const al::SensorMsg*) -> bool

auto isMsgCheckIsCardboardBox(const al::SensorMsg*) -> bool

auto isMsgChorobonAttack(const al::SensorMsg*) -> bool

auto isMsgClearFire(const al::SensorMsg*) -> bool

auto isMsgCollectAnimalTouchCollide(const al::SensorMsg*) -> bool

auto isMsgCollisionImpulse(const al::SensorMsg*) -> bool

auto isMsgConductLightning(const al::SensorMsg*) -> bool

auto isMsgConfirmFrailBox(const al::SensorMsg*) -> bool

auto isMsgConfirmBrokenFrailBox(const al::SensorMsg*) -> bool

auto isMsgDamageBallAttack(const al::SensorMsg*) -> bool

auto isMsgDamageBallBodyAttack(const al::SensorMsg*) -> bool

auto isMsgDigPointSmell(const al::SensorMsg*) -> bool

auto isMsgDonsukeAttack(const al::SensorMsg*) -> bool

auto isMsgDonsukeGroundAttack(const al::SensorMsg*) -> bool

auto isMsgDonsukePush(const al::SensorMsg*) -> bool

auto isMsgDragonAttack(const al::SensorMsg*) -> bool

auto isMsgEatExplosion(const al::SensorMsg*) -> bool

auto isMsgElectricWireNoLimitDistance(const al::SensorMsg*) -> bool

auto isMsgEnableInSaucePan(const al::SensorMsg*) -> bool

auto isMsgEnableMapCheckPointWarp(const al::SensorMsg*) -> bool

auto isMsgEndInSaucePan(const al::SensorMsg*) -> bool

auto isMsgEnemyAttack2D(const al::SensorMsg*) -> bool

auto isMsgEnemyAttack3D(const al::SensorMsg*) -> bool

auto isMsgEnemyAttackDash(const al::SensorMsg*) -> bool

auto isMsgFireBrosFireBallCollide(const al::SensorMsg*) -> bool

auto isMsgFireDamageAll(const al::SensorMsg*) -> bool

auto isMsgHackAttackFire(const al::SensorMsg*) -> bool

auto isMsgFireSwitchFire(const al::SensorMsg*) -> bool

auto isMsgEnemyAttackFireCollision(const al::SensorMsg*) -> bool

auto isMsgEnemyAttackTRex(const al::SensorMsg*) -> bool

auto isMsgPoisonDamageAll(const al::SensorMsg*) -> bool

auto isMsgEnemyAttackPoison(const al::SensorMsg*) -> bool

auto isMsgHackAttackPoison(const al::SensorMsg*) -> bool

auto isMsgPaintAttackPoison(const al::SensorMsg*) -> bool

auto isMsgConfirmPaintObj(const al::SensorMsg*) -> bool

auto isMsgConfirmPaintObjForSeed(const al::SensorMsg*) -> bool

auto isMsgEnemyAttackStrong(const al::SensorMsg*) -> bool

auto isMsgEnemyKick(const al::SensorMsg*) -> bool

auto isMsgRabbitKick(const al::SensorMsg*) -> bool

auto isMsgEnemyObjBreak(const al::SensorMsg*) -> bool

auto isMsgFireBlowerAttack(const al::SensorMsg*) -> bool

auto isMsgFishingAttack(const al::SensorMsg*) -> bool

auto isMsgFishingCancel(const al::SensorMsg*) -> bool

auto isMsgFishingFishApproach(const al::SensorMsg*) -> bool

auto isMsgFishingFishFloatTouch(const al::SensorMsg*) -> bool

auto isMsgFishingItemGet(const al::SensorMsg*) -> bool

auto isMsgFishingLineTouch(const al::SensorMsg*) -> bool

auto isMsgFishingStart(const al::SensorMsg*) -> bool

auto isMsgFishingUpImmediately(const al::SensorMsg*) -> bool

auto isMsgFishingUpImmediatelyPrepare(const al::SensorMsg*) -> bool

auto isMsgFishingWait(const al::SensorMsg*) -> bool

auto isMsgFrogHackTrample(const al::SensorMsg*) -> bool

auto isMsgGamaneBullet(const al::SensorMsg*) -> bool

auto isMsgGamaneBulletThrough(const al::SensorMsg*) -> bool

auto isMsgGamaneBulletForCoinFlower(const al::SensorMsg*) -> bool

auto isMsgGemyAim(const al::SensorMsg*) -> bool

auto isMsgGhostCancel(const al::SensorMsg*) -> bool

auto isMsgGhostPlay(const al::SensorMsg*) -> bool

auto isMsgGhostRecordEnd(const al::SensorMsg*) -> bool

auto isMsgGhostRecordStart(const al::SensorMsg*) -> bool

auto isMsgGhostRecordStartOk(const al::SensorMsg*) -> bool

auto isMsgGhostReverse(const al::SensorMsg*) -> bool

auto isMsgGhostStop(const al::SensorMsg*) -> bool

auto isMsgGiantWanderBossAttack(const al::SensorMsg*) -> bool

auto isMsgGiantWanderBossBulletAttack(const al::SensorMsg*) -> bool

auto isMsgGiantWanderBossBulletPush(const al::SensorMsg*) -> bool

auto isMsgGoldHammerAttack(const al::SensorMsg*) -> bool

auto isMsgGrowFlowerSeedDisablePush(const al::SensorMsg*) -> bool

auto isMsgGrowFlowerSeedNear(const al::SensorMsg*) -> bool

auto isMsgGrowPlantPush(const al::SensorMsg*) -> bool

auto isMsgGrowerAttack(const al::SensorMsg*) -> bool

auto isMsgGrowerWallAttack(const al::SensorMsg*) -> bool

auto isMsgGunetterAttack(const al::SensorMsg*) -> bool

auto isMsgGunetterBodyTouch(const al::SensorMsg*) -> bool

auto isMsgGunetterPush(const al::SensorMsg*) -> bool

auto isMsgHackAttack(const al::SensorMsg*) -> bool

auto isMsgHackAttackKick(const al::SensorMsg*) -> bool

auto isMsgHackAttackMapObj(const al::SensorMsg*) -> bool

auto isMsgHackBrosContact(const al::SensorMsg*) -> bool

auto isMsgHackDeathAreaSelfCheck(const al::SensorMsg*) -> bool

auto isMsgHackDemoEnd(const al::SensorMsg*) -> bool

auto isMsgHackDemoStart(const al::SensorMsg*) -> bool

auto isMsgHackInvalidEscape(const al::SensorMsg*) -> bool

auto isMsgHackInvalidEscapeNoReaction(const al::SensorMsg*) -> bool

auto isMsgHackMarioCheckpointFlagWarp(const al::SensorMsg*) -> bool

auto isMsgHackMarioDead(const al::SensorMsg*) -> bool

auto isMsgHackMarioDemo(const al::SensorMsg*) -> bool

auto isMsgHackMarioInWater(const al::SensorMsg*) -> bool

auto isMsgHackMoveRockForestPush(const al::SensorMsg*) -> bool

auto isMsgHackSelfCeilingCheckMiss(const al::SensorMsg*) -> bool

auto isMsgHackSyncDamageVisibility(const al::SensorMsg*) -> bool

auto isMsgHackUpperPunch(const al::SensorMsg*) -> bool

auto isMsgHackObjUpperPunch(const al::SensorMsg*) -> bool

auto isMsgHammerAttackDown(const al::SensorMsg*) -> bool

auto isMsgHammerAttackSide(const al::SensorMsg*) -> bool

auto isMsgHammerAttackSideCollide(const al::SensorMsg*) -> bool

auto isMsgHammerBrosHammerEnemyAttack(const al::SensorMsg*) -> bool

auto isMsgHammerBrosHammerHackAttack(const al::SensorMsg*) -> bool

auto isMsgHammerBrosHammerSearch(const al::SensorMsg*) -> bool

auto isMsgHipDropTransformReverse(const al::SensorMsg*) -> bool

auto isMsgHipDropTransformTransform(const al::SensorMsg*) -> bool

auto isMsgHipDropTransformingUp(const al::SensorMsg*) -> bool

auto isMsgHipDropTransformingDown(const al::SensorMsg*) -> bool

auto isMsgHipDropTransformingFinish(const al::SensorMsg*) -> bool

auto isMsgHitGrowFlowerPot(const al::SensorMsg*) -> bool

auto isMsgHitGrowPlantPot(const al::SensorMsg*) -> bool

auto isMsgHosuiAttack(const al::SensorMsg*) -> bool

auto isMsgHosuiAttackCollide(const al::SensorMsg*) -> bool

auto isMsgHosuiAttackNoEffect(const al::SensorMsg*) -> bool

auto isMsgHosuiAttackStrong(const al::SensorMsg*) -> bool

auto isMsgHosuiTouch(const al::SensorMsg*) -> bool

auto isMsgHosuiTrample(const al::SensorMsg*) -> bool

auto isMsgHosuiTrampleReflect(const al::SensorMsg*) -> bool

auto isMsgHosuiTrampleReflectHigh(const al::SensorMsg*) -> bool

auto isMsgIgnoreTouchTarget(const al::SensorMsg*) -> bool

auto isMsgIgnorePushMotorcycle(const al::SensorMsg*) -> bool

auto isMsgIcicleAttack(const al::SensorMsg*) -> bool

auto isMsgIgnoreMirrorWarp(const al::SensorMsg*) -> bool

auto isMsgIgnoredByRunawayNpc(const al::SensorMsg*) -> bool

auto isMsgImplantGrowFlowerSeed(const al::SensorMsg*) -> bool

auto isMsgInitTouchTargetInfo(const al::SensorMsg*) -> bool

auto isMsgItemAmiiboKoopa(const al::SensorMsg*) -> bool

auto isMsgIsExistPukupuku(const al::SensorMsg*) -> bool

auto isMsgJangoAttack(const al::SensorMsg*) -> bool

auto isMsgJangoRemoveCap(const al::SensorMsg*) -> bool

auto isMsgKakkuKick(const al::SensorMsg*) -> bool

auto isMsgKoopaBindStart(const al::SensorMsg*) -> bool

auto isMsgKoopaCapPlayerFocusTarget(const al::SensorMsg*) -> bool

auto isMsgKoopaCapPunchFinishL(const al::SensorMsg*) -> bool

auto isMsgKoopaCapPunchFinishR(const al::SensorMsg*) -> bool

auto isMsgKoopaCapPunchInvincibleL(const al::SensorMsg*) -> bool

auto isMsgKoopaCapPunchInvincibleR(const al::SensorMsg*) -> bool

auto isMsgKoopaCapPunchKnockBackL(const al::SensorMsg*) -> bool

auto isMsgKoopaCapPunchKnockBackR(const al::SensorMsg*) -> bool

auto isMsgKoopaCapPunchL(const al::SensorMsg*) -> bool

auto isMsgKoopaCapPunchR(const al::SensorMsg*) -> bool

auto isMsgKoopaCapSpinAttack(const al::SensorMsg*) -> bool

auto isMsgKoopaCatchKoopaCap(const al::SensorMsg*) -> bool

auto isMsgKoopaDashPunchAttack(const al::SensorMsg*) -> bool

auto isMsgKoopaFire2D(const al::SensorMsg*) -> bool

auto isMsgKoopaFireBallAttack(const al::SensorMsg*) -> bool

auto isMsgKoopaHackDamage(const al::SensorMsg*) -> bool

auto isMsgKoopaHackPunch(const al::SensorMsg*) -> bool

auto isMsgKoopaHackPunchCollide(const al::SensorMsg*) -> bool

auto isMsgKoopaHackTrample(const al::SensorMsg*) -> bool

auto isMsgKoopaInvalidHackPunchFaceToCollision(const al::SensorMsg*) -> bool

auto isMsgKoopaRingBeamInvalidTouch(const al::SensorMsg*) -> bool

auto isMsgKoopaTailAttack(const al::SensorMsg*) -> bool

auto isMsgKoopaTouchFloor(const al::SensorMsg*) -> bool

auto isMsgKouraAttack2D(const al::SensorMsg*) -> bool

auto isMsgKouraItemGet2D(const al::SensorMsg*) -> bool

auto isMsgKuribo2DTouch(const al::SensorMsg*) -> bool

auto isMsgKuriboCollisionDamage(const al::SensorMsg*) -> bool

auto isMsgKuriboCollisionKill(const al::SensorMsg*) -> bool

auto isMsgKuriboFlick(const al::SensorMsg*) -> bool

auto isMsgKuriboGirlAttack(const al::SensorMsg*) -> bool

auto isMsgKuriboGirlLove(const al::SensorMsg*) -> bool

auto isMsgKuriboTop(const al::SensorMsg*) -> bool

auto isMsgKuriboTowerNum(const al::SensorMsg*) -> bool

auto isMsgLaunchBlow(const al::SensorMsg*) -> bool

auto isMsgLineDancerLink(const al::SensorMsg*) -> bool

auto isMsgLongPushSensorHit(const al::SensorMsg*) -> bool

auto isMsgLongPushBoxHit(const al::SensorMsg*) -> bool

auto isMsgMagnetBulletAttack(const al::SensorMsg*) -> bool

auto isMsgMeganeAttack(const al::SensorMsg*) -> bool

auto isMsgMeganeHackTrample(const al::SensorMsg*) -> bool

auto isMsgMofumofuBodyChainExplode(const al::SensorMsg*) -> bool

auto isMsgMofumofuBulletUnexplosion(const al::SensorMsg*) -> bool

auto isMsgMoonBasementAttackMeteor(const al::SensorMsg*) -> bool

auto isMsgMoonBasementBreakShockwaveMeteor(const al::SensorMsg*) -> bool

auto isMsgMoonBasementRockSyncClippingRegist(const al::SensorMsg*) -> bool

auto isMsgMoonBasementRockSyncClippingInvalidate(const al::SensorMsg*) -> bool

auto isMsgMoonBasementRockSyncClippingValidate(const al::SensorMsg*) -> bool

auto isMsgMoonBasementRockThroughCollision(const al::SensorMsg*) -> bool

auto isMsgMorningStarWarpEnd(const al::SensorMsg*) -> bool

auto isMsgMorningStarWarpStart(const al::SensorMsg*) -> bool

auto isMsgMotorcycleAttack(const al::SensorMsg*) -> bool

auto isMsgMotorcycleCollideParkingLot(const al::SensorMsg*) -> bool

auto isMsgMotorcycleDashAttack(const al::SensorMsg*) -> bool

auto isMsgMotorcycleDashCollide(const al::SensorMsg*) -> bool

auto isMsgCactusNeedleAttack(const al::SensorMsg*) -> bool

auto isMsgCactusNeedleAttackStrong(const al::SensorMsg*) -> bool

auto isMsgNoLimitTouchJump(const al::SensorMsg*) -> bool

auto isMsgNoticePlayerDamage(const al::SensorMsg*) -> bool

auto isMsgNpcScareByEnemy(const al::SensorMsg*) -> bool

auto isMsgVolleyballNpcScareByEnemy(const al::SensorMsg*) -> bool

auto isMsgObjSnapForce(const al::SensorMsg*) -> bool

auto isMsgPackunEatCancel(const al::SensorMsg*) -> bool

auto isMsgPackunEatEnd(const al::SensorMsg*) -> bool

auto isMsgPackunEatStart(const al::SensorMsg*) -> bool

auto isMsgPackunEatStartFollow(const al::SensorMsg*) -> bool

auto isMsgPaint(const al::SensorMsg*) -> bool

auto isMsgPaintTexture(const al::SensorMsg*) -> bool

auto isMsgCheckPaintClear(const al::SensorMsg*) -> bool

auto isMsgCheckPaintAlpha(const al::SensorMsg*) -> bool

auto isMsgPartyPopperSoundAttack(const al::SensorMsg*) -> bool

auto isMsgPechoSpot(const al::SensorMsg*) -> bool

auto isMsgPlayerBallToss(const al::SensorMsg*) -> bool

auto isMsgPlayerCarryCameraSubjectiveStart(const al::SensorMsg*) -> bool

auto isMsgPlayerCarryCameraSubjectiveEnd(const al::SensorMsg*) -> bool

auto isMsgPlayerCarryShineGetStart(const al::SensorMsg*) -> bool

auto isMsgPlayerCarryShineGetEnd(const al::SensorMsg*) -> bool

auto isMsgPlayerCapCatch(const al::SensorMsg*) -> bool

auto isMsgPlayerCapHipDrop(const al::SensorMsg*) -> bool

auto isMsgPlayerCapPush(const al::SensorMsg*) -> bool

auto isMsgPlayerCapRecovery(const al::SensorMsg*) -> bool

auto isMsgPlayerCapTouchJump(const al::SensorMsg*) -> bool

auto isMsgPlayerCapTrample(const al::SensorMsg*) -> bool

auto isMsgPlayerCoinDashGet(const al::SensorMsg*) -> bool

auto isMsgPlayerEyePriorityTarget(const al::SensorMsg*) -> bool

auto isMsgPlayerDisregardHomingAttack(const al::SensorMsg*) -> bool

auto isMsgPlayerDisregardTargetMarker(const al::SensorMsg*) -> bool

auto isMsgPlayerEquipKoopaCap(const al::SensorMsg*) -> bool

auto isMsgPlayerFireBallAttack2D(const al::SensorMsg*) -> bool

auto isMsgPlayerFireBallAttack3D(const al::SensorMsg*) -> bool

auto isMsgPlayerHipDropDemoTrigger(const al::SensorMsg*) -> bool

auto isMsgPlayerHipDropHipDropSwitch(const al::SensorMsg*) -> bool

auto isMsgPlayerItemGet2D(const al::SensorMsg*) -> bool

auto isMsgPlayerJumpTakeOffFloor(const al::SensorMsg*) -> bool

auto isMsgPlayerObjectWallHit(const al::SensorMsg*) -> bool

auto isMsgPlayerObjLeapFrog(const al::SensorMsg*) -> bool

auto isMsgPlayerPenguinAttack(const al::SensorMsg*) -> bool

auto isMsgPlayerPenguinAttackReflect(const al::SensorMsg*) -> bool

auto isMsgPlayerPoleClimbKeep(const al::SensorMsg*) -> bool

auto isMsgPlayerPoleClimbReaction(const al::SensorMsg*) -> bool

auto isMsgPlayerRabbitGet(const al::SensorMsg*) -> bool

auto isMsgPlayerRollingObjHit(const al::SensorMsg*) -> bool

auto isMsgPlayerRollingWallHitDown(const al::SensorMsg*) -> bool

auto isMsgPlayerRollingWallHitMove(const al::SensorMsg*) -> bool

auto isMsgPlayerStartGrabCeil(const al::SensorMsg*) -> bool

auto isMsgPlayerStartWallJump(const al::SensorMsg*) -> bool

auto isMsgPlayerEndGrabCeil(const al::SensorMsg*) -> bool

auto isMsgPlayerSwordAttack(const al::SensorMsg*) -> bool

auto isMsgPlayerTouchFloorJumpCode(const al::SensorMsg*) -> bool

auto isMsgPlayerTrample2D(const al::SensorMsg*) -> bool

auto isMsgPlayerUpperPunch2D(const al::SensorMsg*) -> bool

auto isMsgPlayerObjUpperPunch2D(const al::SensorMsg*) -> bool

auto isMsgPropellerAttack(const al::SensorMsg*) -> bool

auto isMsgPukupukuDash(const al::SensorMsg*) -> bool

auto isMsgPukupukuKiss(const al::SensorMsg*) -> bool

auto isMsgPukupukuRollingAttack(const al::SensorMsg*) -> bool

auto isMsgPunchMachinePunchHook(const al::SensorMsg*) -> bool

auto isMsgPunchMachinePunchStraight(const al::SensorMsg*) -> bool

auto isMsgPunchMachinePunchUpper(const al::SensorMsg*) -> bool

auto isMsgPush2D(const al::SensorMsg*) -> bool

auto isMsgPushToFish(const al::SensorMsg*) -> bool

auto isMsgPushToMotorcycle(const al::SensorMsg*) -> bool

auto isMsgPushToPlayer(const al::SensorMsg*) -> bool

auto isMsgRadishAttack(const al::SensorMsg*) -> bool

auto isMsgRadishReflect(const al::SensorMsg*) -> bool

auto isMsgRaceStart(const al::SensorMsg*) -> bool

auto isMsgRaceStop(const al::SensorMsg*) -> bool

auto isMsgRaceWait(const al::SensorMsg*) -> bool

auto isMsgRequestChangeFireFlower(const al::SensorMsg*) -> bool

auto isMsgRequestChangeKinokoSuper(const al::SensorMsg*) -> bool

auto isMsgRequestPlayerJumpBreakFloor(const al::SensorMsg*) -> bool

auto isMsgRequestPlayerJump(const al::SensorMsg*) -> bool

auto isMsgRequestPlayerTrampleJump(const al::SensorMsg*) -> bool

auto isMsgRequestPlayerSpinJump(const al::SensorMsg*) -> bool

auto isMsgRequestSphinxJump(const al::SensorMsg*) -> bool

auto isMsgRideOnEnd(const al::SensorMsg*) -> bool

auto isMsgRideOnRelease(const al::SensorMsg*) -> bool

auto isMsgRideOnStart(const al::SensorMsg*) -> bool

auto isMsgRocketFlowerExtension(const al::SensorMsg*) -> bool

auto isMsgSandSharkAttack(const al::SensorMsg*) -> bool

auto isMsgSeedAttack(const al::SensorMsg*) -> bool

auto isMsgSeedAttackBig(const al::SensorMsg*) -> bool

auto isMsgSeedAttackHold(const al::SensorMsg*) -> bool

auto isMsgSeedItemGet(const al::SensorMsg*) -> bool

auto isMsgSeedReflect(const al::SensorMsg*) -> bool

auto isMsgSeedTouch(const al::SensorMsg*) -> bool

auto isMsgSenobiCancelStretch(const al::SensorMsg*) -> bool

auto isMsgSenobiPunchBlockTransparent(const al::SensorMsg*) -> bool

auto isMsgSenobiPartsMove(const al::SensorMsg*) -> bool

auto isMsgSenobiTrample(const al::SensorMsg*) -> bool

auto isMsgShibakenApproach(const al::SensorMsg*) -> bool

auto isMsgShibakenKick(const al::SensorMsg*) -> bool

auto isMsgSkaterAttack(const al::SensorMsg*) -> bool

auto isMsgSpherePush(const al::SensorMsg*) -> bool

auto isMsgSphinxJumpAttack(const al::SensorMsg*) -> bool

auto isMsgSphinxQuizRouteKill(const al::SensorMsg*) -> bool

auto isMsgSphinxRideAttack(const al::SensorMsg*) -> bool

auto isMsgSphinxRideAttackReflect(const al::SensorMsg*) -> bool

auto isMsgSphinxRideAttackTouchThrough(const al::SensorMsg*) -> bool

auto isMsgSphinxRideAttackTouch(const al::SensorMsg*) -> bool

auto isMsgStampTo2D(const al::SensorMsg*) -> bool

auto isMsgStartHack(const al::SensorMsg*) -> bool

auto isMsgStartInSaucePan(const al::SensorMsg*) -> bool

auto isMsgStatueDrop(const al::SensorMsg*) -> bool

auto isMsgStatueTrampleReflect(const al::SensorMsg*) -> bool

auto isMsgStatuePush(const al::SensorMsg*) -> bool

auto isMsgStatueSnap(const al::SensorMsg*) -> bool

auto isMsgSunshineAttack(const al::SensorMsg*) -> bool

auto isMsgTankBullet(const al::SensorMsg*) -> bool

auto isMsgTankBulletNoReaction(const al::SensorMsg*) -> bool

auto isMsgTankExplosion(const al::SensorMsg*) -> bool

auto isMsgTankHackTrample(const al::SensorMsg*) -> bool

auto isMsgTankKickHack(const al::SensorMsg*) -> bool

auto isMsgTankKickEnemy(const al::SensorMsg*) -> bool

auto isMsgTankLookOn(const al::SensorMsg*) -> bool

auto isMsgTestPunch(const al::SensorMsg*) -> bool

auto isMsgTestPunchStrong(const al::SensorMsg*) -> bool

auto isMsgTimerAthleticDemoStart(const al::SensorMsg*) -> bool

auto isMsgTouchDoorDrumn(const al::SensorMsg*) -> bool

auto isMsgTouchFireDrum2D(const al::SensorMsg*) -> bool

auto isMsgTrashBoxIn(const al::SensorMsg*) -> bool

auto isMsgTRexAttack(const al::SensorMsg*) -> bool

auto isMsgTRexAttackCollideAll(const al::SensorMsg*) -> bool

auto isMsgTRexAttackCollideBody(const al::SensorMsg*) -> bool

auto isMsgTRexAttackCollideHead(const al::SensorMsg*) -> bool

auto isMsgTRexDashAttack(const al::SensorMsg*) -> bool

auto isMsgTRexScrollPartsBreakWith(const al::SensorMsg*) -> bool

auto isMsgTsukkunForceCancelCollide(const al::SensorMsg*) -> bool

auto isMsgTsukkunHoldCollide(const al::SensorMsg*) -> bool

auto isMsgTsukkunThroughCollide(const al::SensorMsg*) -> bool

auto isMsgTsukkunThrustAll(const al::SensorMsg*) -> bool

auto isMsgTsukkunThrust(const al::SensorMsg*, bool*) -> bool

auto isMsgTsukkunThrustCollide(const al::SensorMsg*, bool*) -> bool

auto isMsgTsukkunNoTrace(const al::SensorMsg*) -> bool

auto isMsgTsukkunThrustHole(const al::SensorMsg*) -> bool

auto isMsgUtsuboAttack(const al::SensorMsg*) -> bool

auto isMsgWanderBossCameraRange(const al::SensorMsg*) -> bool

auto isMsgWanwanEnemyAttack(const al::SensorMsg*) -> bool

auto isMsgWanwanBlockAttack(const al::SensorMsg*) -> bool

auto isMsgWanwanHoleIn(const al::SensorMsg*) -> bool

auto isMsgWaterRoadIn(const al::SensorMsg*) -> bool

auto isMsgWaterRoadNear(const al::SensorMsg*) -> bool

auto isMsgWanwanPush(const al::SensorMsg*) -> bool

auto isMsgWanwanReboundAttack(const al::SensorMsg*) -> bool

auto isMsgWeaponItemGet(const al::SensorMsg*) -> bool

auto isMsgWhipAttack(const al::SensorMsg*) -> bool

auto isMsgWhipBind(const al::SensorMsg*) -> bool

auto isMsgWhipHold(const al::SensorMsg*) -> bool

auto isMsgWhipThrow(const al::SensorMsg*) -> bool

auto isMsgYokinBallAttack(const al::SensorMsg*) -> bool

auto isMsgYoshiDirectEat(const al::SensorMsg*) -> bool

auto isMsgYoshiTongueAttack(const al::SensorMsg*) -> bool

auto isMsgYoshiTongueEatBind(const al::SensorMsg*) -> bool

auto isMsgYoshiTongueEatBindCancel(const al::SensorMsg*) -> bool

auto isMsgYoshiTongueEatBindFinish(const al::SensorMsg*) -> bool

auto isMsgYoshiTongueEatHomingTarget(const al::SensorMsg*) -> bool

auto isMsgYukimaruPush(const al::SensorMsg*) -> bool

auto isMsgKillerAttackNoExplode(const al::SensorMsg*) -> bool

auto isMsgKillerMagnumAttack(const al::SensorMsg*) -> bool

auto isMsgKillerMagnumHackAttack(const al::SensorMsg*) -> bool

auto isMsgGabuzouAttack(const al::SensorMsg*) -> bool

auto isMsgStackerRollingAttack(const al::SensorMsg*) -> bool

auto isMsgStackerCapBoostAttack(const al::SensorMsg*) -> bool

auto isMsgIgnoreIgnitionBomb(const al::SensorMsg*) -> bool

auto isMsgExplosionReflectBomb(const al::SensorMsg*) -> bool

auto isMsgGolemStampPress(const al::SensorMsg*) -> bool

void setMsgYoshiTongueEatBindRadiusAndOffset(const al::SensorMsg*, f32, f32)

void setMsgYoshiTongueEatBindScale(const al::SensorMsg*, f32)

auto isMsgTsukkunThrustSpin(const al::SensorMsg*, bool*) -> bool

auto isMsgTsukkunThrustReflect(const al::SensorMsg*, bool*) -> bool

auto isMsgTsukkunThrustHitReflectCollide(const al::SensorMsg*, bool*) -> bool

auto isMsgTsukkunThrustReflectCollide(const al::SensorMsg*, bool*) -> bool

auto isMsgSwitchOnWithSaveRequest(const al::SensorMsg*, SaveObjInfo**) -> bool

auto isMsgNpcCapReactionAll(const al::SensorMsg*) -> bool

auto isMsgHackNpcCapReactionAll(const al::SensorMsg*) -> bool

auto checkMsgNpcTrampleReactionAll(const al::SensorMsg*, const al::HitSensor*, const al::HitSensor*, bool) -> bool

auto isMsgPlayerAndCapObjHipDropReflectAll(const al::SensorMsg*) -> bool

auto isMsgKoopaCapPunchAll(const al::SensorMsg*) -> bool

auto isMsgKoopaCapPunchInvincibleAll(const al::SensorMsg*) -> bool

auto isMsgKoopaCapPunchFinishAll(const al::SensorMsg*) -> bool

auto isMsgItemGet(const al::SensorMsg*) -> bool

auto isMsgItemGetByWeapon(const al::SensorMsg*) -> bool

auto isMsgItemGet2D(const al::SensorMsg*) -> bool

auto isMsgBlockUpperPunch2D(const al::SensorMsg*) -> bool

auto isMsgItemGetAll(const al::SensorMsg*) -> bool

auto isMsgShineGet(const al::SensorMsg*) -> bool

auto isMsgShineGet2D(const al::SensorMsg*) -> bool

auto isMsgShineReaction(const al::SensorMsg*) -> bool

auto isMsgKillByShineGet(const al::SensorMsg*) -> bool

auto isMsgKillByHomeDemo(const al::SensorMsg*) -> bool

auto isMsgEndHomeDemo(const al::SensorMsg*) -> bool

auto isMsgBreakBySword(const al::SensorMsg*) -> bool

auto isMsgPressDown(const al::SensorMsg*) -> bool

auto isMsgPlayerAndCapObjHipDropAll(const al::SensorMsg*) -> bool

auto isMsgAttackDirect(const al::SensorMsg*) -> bool

auto isMsgBlowDown(const al::SensorMsg*) -> bool

auto isMsgTrampleReflectAll(const al::SensorMsg*) -> bool

auto isMsgThrowObjHit(const al::SensorMsg*) -> bool

auto isMsgThrowObjHitReflect(const al::SensorMsg*) -> bool

auto isMsgPlayerAndCapHipDropAll(const al::SensorMsg*) -> bool

auto isMsgUpperPunchAll(const al::SensorMsg*) -> bool

auto sendMsgBlockUpperPunch2D(al::HitSensor* source, al::HitSensor* target) -> bool

auto isMsgBlockReaction2D(const al::SensorMsg*) -> bool

auto isMsgBlockReaction3D(const al::SensorMsg*) -> bool

auto isMsgBlockReactionAll(const al::SensorMsg*) -> bool

auto isMsgBreakFrailBox(const al::SensorMsg*) -> bool

auto isMsgDamageFrailBox(const al::SensorMsg*) -> bool

auto isMsgChorobonReaction(const al::SensorMsg*) -> bool

auto isMsgBreakSignBoard(const al::SensorMsg*) -> bool

auto isMsgBreakCollapseSandHill(const al::SensorMsg*) -> bool

void calcBlowDownDir(sead::Vector3f*, const al::SensorMsg*, al::HitSensor* source, al::HitSensor* target)

auto tryGetTsukkunThrustDir(sead::Vector3f*, const al::SensorMsg*) -> bool

auto isMsgPlayerDamage(const al::SensorMsg*) -> bool

auto isMsgPlayerDamage2D(const al::SensorMsg*) -> bool

auto isMsgPlayerDamageBlowDown(const al::SensorMsg*) -> bool

auto isMsgPlayerJumpRequestAll(const al::SensorMsg*) -> bool

auto trySendMsgHackPunchToCeil(al::LiveActor*, al::HitSensor*) -> bool

auto trySendMsgHackPunchToSensor(al::LiveActor*, al::HitSensor* source, al::HitSensor* target) -> bool

auto isMsgDashPanel(const al::SensorMsg*, s32*) -> bool

auto isMsgNetworkShootingShot(const al::SensorMsg*, s32) -> bool

auto isMsgNetworkShootingChargeShot(const al::SensorMsg*, s32) -> bool

auto isMsgRaceReturnToCourse(const al::SensorMsg*, sead::Vector3f*, sead::Vector3f*) -> bool

auto isFallingTargetMoonBasementRock(const al::SensorMsg*) -> bool

auto tryGetTestPunchInfo(sead::Vector3f*, s32*, const al::SensorMsg*, s32) -> bool

auto tryGetTestPunchTeamId(s32*, const al::SensorMsg*) -> bool

auto tryGetPunchGuard(s32*, const al::SensorMsg*, s32) -> bool

auto tryGetTsukkunThrustInfo(sead::Vector3f*, s32*, const al::SensorMsg*) -> bool

auto tryGetTsukkunThrustReflectDir(sead::Vector3f*, const al::SensorMsg*) -> bool

auto tryGetTsukkunThrustHole(sead::Vector3f*, sead::Vector3f*, const al::SensorMsg*) -> bool

auto tryGetRequestPlayerJumpInfo(f32*, const al::SensorMsg*) -> bool

auto tryGetRequestPlayerTrampleJumpInfo(f32*, const al::SensorMsg*) -> bool

auto tryGetRequestPlayerSpinJumpInfo(f32*, const al::SensorMsg*) -> bool

auto tryGetRequestSphinxJumpInfo(f32*, const al::SensorMsg*) -> bool

auto tryGetTouchTargetInfo(TouchTargetInfo**, const al::SensorMsg*) -> bool

auto tryGetTouchTargetInfoCollisionTouchPos(sead::Vector3f*, const al::SensorMsg*) -> bool

auto tryInitTouchTargetInfoBySensorOffset(const al::SensorMsg*, const al::HitSensor*, const sead::Vector3f&, const sead::Vector3f&) -> bool

auto tryInitTouchTargetInfoByConnector(const al::SensorMsg*, const al::MtxConnector*, const sead::Vector3f&, const sead::Vector3f&, bool) -> bool

auto tryCalcCollisionImpulse(sead::Vector3f*, f32, const sead::Vector3f&, f32, const al::SensorMsg*) -> bool

auto tryInitWhipTarget(const al::SensorMsg*, al::HitSensor*, const sead::Vector3f*) -> bool

auto tryGetWhipThrowDir(sead::Vector3f*, const al::SensorMsg*) -> bool

auto tryMagnetPower(bool*, const al::SensorMsg*) -> bool

auto tryMagnetBulletAttack(f32*, const al::SensorMsg*) -> bool

auto isMsgTrampolineCrackJump(f32*, f32*, const al::SensorMsg*) -> bool

void requestHitReactionToAttacker(const al::SensorMsg*, const al::HitSensor*, const al::HitSensor*)

void requestHitReactionToAttacker(const al::SensorMsg*, const al::HitSensor*, const sead::Vector3f&)

auto tryGetCapTouchWallHitPos(sead::Vector3f*, const al::SensorMsg*) -> bool

auto tryGetCapTouchWallNormal(sead::Vector3f*, const al::SensorMsg*) -> bool

auto isCapRethrowReturnOnly(const al::SensorMsg*) -> bool

auto tryGetCapRethrowPos(sead::Vector3f*, const al::SensorMsg*) -> bool

auto tryGetCapRethrowFront(sead::Vector3f*, const al::SensorMsg*) -> bool

auto tryGetCapRethrowUp(sead::Vector3f*, const al::SensorMsg*) -> bool

auto tryGetHackBlowJump(sead::Vector3f*, f32*, const al::SensorMsg*) -> bool

auto tryGetGolemStampPushV(f32*, const al::SensorMsg*) -> bool

auto tryGetGolemStampPushH(f32*, const al::SensorMsg*) -> bool

auto tryGetRequestPlayerWaitAnim(const char**, const al::SensorMsg*) -> bool

auto tryGetCapChangeGiant(f32*, s32*, const al::SensorMsg*) -> bool

auto tryGetByugoBlowForce(sead::Vector3f*, const al::SensorMsg*) -> bool

auto tryGetObjSnapForce(sead::Vector3f*, const al::SensorMsg*) -> bool

void getPackunEatCancelPosAndFront(sead::Vector3f*, sead::Vector3f*, const al::SensorMsg*)

auto tryGetPackunEatEndPos(sead::Vector3f*, const al::SensorMsg*) -> bool

auto tryGetPackunEatEndDir(sead::Vector3f*, const al::SensorMsg*) -> bool

auto tryGetPackunEatStartFollowPos(const sead::Vector3f**, const al::SensorMsg*) -> bool

auto tryGetFireBlowerAttackPos(sead::Vector3f*, const al::SensorMsg*) -> bool

auto tryGetFireBlowerAttackDir(sead::Vector3f*, const al::SensorMsg*) -> bool

auto tryGetFireBlowerAttackRadius(f32*, const al::SensorMsg*) -> bool

auto tryGetPaintColor(sead::Color4u8*, const al::SensorMsg*) -> bool

auto tryGetPaintSize(f32*, const al::SensorMsg*) -> bool

auto tryGetPaintDrawType(s32*, const al::SensorMsg*) -> bool

auto tryGetPaintTextureSize(f32*, const al::SensorMsg*) -> bool

auto tryGetPaintTextureRotation(f32*, const al::SensorMsg*) -> bool

auto tryGetPaintTextureDrawType(s32*, const al::SensorMsg*) -> bool

auto tryGetCheckPaintClearColor(sead::Color4u8*, const al::SensorMsg*) -> bool

auto tryGetCheckPaintClearPos(sead::Vector3f*, const al::SensorMsg*) -> bool

auto tryGetCheckPaintClearDrawType(s32*, const al::SensorMsg*) -> bool

auto tryGetCheckPaintAlphaPos(sead::Vector3f*, const al::SensorMsg*) -> bool

auto tryGetSenobiPartsMoveDistance(f32*, const al::SensorMsg*) -> bool

auto tryGetSenobiPartsCollidedNormal(sead::Vector3f*, const al::SensorMsg*) -> bool

auto tryGetStampTo2DForce(sead::Vector3f*, const al::SensorMsg*) -> bool

auto tryGetGhostStartOkObjId(sead::BufferedSafeStringBase<char>*, const al::SensorMsg*) -> bool

auto tryGetAirExplosionForce(sead::Vector3f*, const al::SensorMsg*) -> bool

auto sendMsgGotogotonOn(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgGotogotonGetJumpPath(al::HitSensor* source, al::HitSensor* target, al::ParabolicPath*) -> bool

auto sendMsgGotogotonGoalExist(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgGotogotonGoalMatch(al::HitSensor* source, al::HitSensor* target, const GotogotonMark*) -> bool

auto isMatchGotogotonGoal(const al::SensorMsg*, const GotogotonMark*) -> bool

auto isMsgGotogotonOn(const al::SensorMsg*) -> bool

auto isMsgGotogotonGoalExist(const al::SensorMsg*) -> bool

auto sendMsgBossMagmaBreathForce(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&) -> bool

auto sendMsgBossMagmaCatchPlayer(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBossMagmaReleasePlayer(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBossMagmaDeadDemoStart(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgBossMagmaDeadDemoEnd(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&) -> bool

auto sendMsgBossMagmaResetPos(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&) -> bool

auto sendMsgBossMagmaQueryToBubble(al::HitSensor* source, al::HitSensor* target) -> bool

auto isMsgBossMagmaCatchPlayer(const al::SensorMsg*) -> bool

auto isMsgBossMagmaReleasePlayer(const al::SensorMsg*) -> bool

auto isMsgBossMagmaDeadDemoStart(const al::SensorMsg*) -> bool

auto isMsgBossMagmaDeadDemoEnd(const al::SensorMsg*) -> bool

auto tryGetBossMagmaDeadDemoEndTargetPos(const al::SensorMsg*, sead::Vector3f*) -> bool

auto tryGetBossMagmaBreathForce(const al::SensorMsg*, sead::Vector3f*) -> bool

auto tryGetBossMagmaResetPos(const al::SensorMsg*, sead::Vector3f*) -> bool

auto isMsgBossMagmaQueryToBubble(const al::SensorMsg*) -> bool

auto getMofumofuBodyChainExplodeDelayStep(const al::SensorMsg*) -> s32

auto isMsgMofumofuReflectAll(const al::SensorMsg*) -> bool

void calcFishingUpJugemDir(sead::Vector3f*, const al::SensorMsg*)

auto getFishingUpFloatPos(const al::SensorMsg*) -> const sead::Vector3f&

auto tryGetFishingUpFloatMaterialCode(const al::SensorMsg*) -> const char*

auto getFishingHookSensor(const al::SensorMsg*) -> al::HitSensor*

auto sendMsgCheckFishingTarget(al::HitSensor* source, al::HitSensor* target, const FishingFish*) -> bool

auto isMsgCheckFishingTarget(const al::SensorMsg*) -> bool

auto getCheckFishingTarget(const al::SensorMsg*) -> const FishingFish*

auto getGunetterPushCenter(const al::SensorMsg*) -> const sead::Vector3f&

auto getGunetterPushRadius(const al::SensorMsg*) -> f32

auto getNumKuriboTowerOn(const al::SensorMsg*) -> u32

auto isMsgPlayerLookAtPosition(const al::SensorMsg*) -> bool

void setMsgPlayerLookAtPosition(const al::SensorMsg*, const sead::Vector3f&)

auto isMsgTargetMarkerPosition(const al::SensorMsg*) -> bool

void setMsgTargetMarkerPosition(const al::SensorMsg*, const sead::Vector3f&)

auto isMsgSandGeyserRaise(const al::SensorMsg*) -> bool

auto tryGetSandGeyserRaise(const al::SensorMsg*, f32*, f32*) -> bool

void tryTreasureBoxPlayerTrampleJump(al::LiveActor*, al::HitSensor* source, al::HitSensor* target, f32)

auto sendMsgPushToPlayerAndKillVelocityToTarget(al::LiveActor*, al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgPushToPlayerAndKillVelocityToTargetH(al::LiveActor*, al::HitSensor* source, al::HitSensor* target) -> bool

auto tryReceivePushAndAddVelocity(al::LiveActor*, const al::SensorMsg*) -> bool

auto tryReceiveMsgPushToPlayerAndAddVelocity(al::LiveActor*, const al::SensorMsg*, const al::HitSensor*, const al::HitSensor*, f32) -> bool

auto tryReceiveMsgPushToPlayerAndAddVelocityH(al::LiveActor*, const al::SensorMsg*, const al::HitSensor*, const al::HitSensor*, f32) -> bool

auto tryReceiveMsgPushToPlayerAndCalcPushTrans(sead::Vector3f*, const al::SensorMsg*, const al::LiveActor*, const al::HitSensor*, const al::HitSensor*, f32) -> bool

auto tryReceiveMsgPushToHackerAndCalcPushTrans(sead::Vector3f*, const al::SensorMsg*, const al::LiveActor*, const al::HitSensor*, const al::HitSensor*, f32, bool) -> bool

auto tryReceiveMsgPushToYoshiNpcAndCalcPushTrans(sead::Vector3f*, const al::SensorMsg*, const al::LiveActor*, const al::HitSensor*, const al::HitSensor*, f32) -> bool

auto tryReceiveMsgPushToCapAndCalcPushTrans(sead::Vector3f*, const al::SensorMsg*, const al::LiveActor*, const al::HitSensor*, const al::HitSensor*, f32) -> bool

auto tryReceiveMsgPushToGrowPlantAndCalcPushTrans(sead::Vector3f*, const al::SensorMsg*, const al::LiveActor*, const al::HitSensor*, const al::HitSensor*, f32) -> bool

auto sendMsgInitCapTarget(al::HitSensor* source, al::HitSensor* target, const CapTargetInfo**) -> bool

auto isMsgInitCapTarget(const al::SensorMsg*) -> bool

void setCapTargetInfo(const al::SensorMsg*, const CapTargetInfo*)

auto tryReceiveMsgInitCapTargetAndSetCapTargetInfo(const al::SensorMsg*, const CapTargetInfo*) -> bool

auto sendMsgTransferHack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgRequestTransferHack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgInitHack(al::HitSensor* source, al::HitSensor* target) -> bool

auto sendMsgEndHack(al::HitSensor* source, al::HitSensor* target, const HackEndParam*) -> bool

auto isMsgTransferHack(const al::SensorMsg*) -> bool

auto isMsgRequestTransferHack(const al::SensorMsg*) -> bool

auto isMsgInitHack(const al::SensorMsg*) -> bool

auto isMsgEndHack(const HackEndParam**, const al::SensorMsg*) -> bool

auto isMsgHackDirectStageInit(IUsePlayerHack**, const al::SensorMsg*) -> bool

auto isMsgKillByBossBattleDemo(const al::SensorMsg*) -> bool

auto isMsgKillByHackFirstDemo(const al::SensorMsg*) -> bool

auto isMsgKillByMoonRockDemo(const al::SensorMsg*) -> bool

auto sendMsgNpcScareByEnemy(al::HitSensor* source, al::HitSensor* target, s32) -> bool

auto tryReceiveMsgNpcScareByEnemyIgnoreTargetHack(const al::SensorMsg*, const CapTargetInfo*) -> bool

auto tryIncrementComboCount(s32*, const al::SensorMsg*) -> bool

auto tryGetMsgComboCount(const al::SensorMsg*) -> ComboCounter*

auto getMsgComboCount(const al::SensorMsg*) -> ComboCounter*

auto isRideOn(const al::HitSensor*, const al::HitSensor*) -> bool

auto isMsgKillBySwitchTimer(const al::SensorMsg*) -> bool

auto isVisibleChameleon(const al::SensorMsg*) -> bool

auto isMsgRequestPlayerStainWet(const al::SensorMsg*, s32*) -> bool

auto tryGetKuriboTowerNum(al::HitSensor* source, al::HitSensor* target) -> s32

void setKuriboTowerNum(const al::SensorMsg*, s32)

auto getSpherePushCenter(const al::SensorMsg*) -> const sead::Vector3f&

auto getSpherePushRadius(const al::SensorMsg*) -> f32

auto getSmellDigPoint(const al::SensorMsg*) -> DigPoint*

void convertCsecTo(s32* minutes, s32* seconds, s32* csec, s32 time)

auto setShadowDropLength(al::LiveActor*, const al::ActorInitInfo&, const char*) -> f32

auto calcShadowDropClippingCenter(sead::Vector3f*, const al::LiveActor*, f32, f32) -> f32

void setShadowDropOffset(al::LiveActor*, const char*, f32)

auto tryCreateWaterSurfaceShadow(const al::ActorInitInfo&, const char*) -> WaterSurfaceShadow*

auto tryCreateWaterSurfaceCoinShadow(const al::ActorInitInfo&) -> WaterSurfaceShadow*

void tryUpdateWaterSurfaceCoinShadow(WaterSurfaceShadow*, al::LiveActor*, f32)

void initHackShadow(al::LiveActor*)

void setupHackShadow(al::LiveActor*)

void endHackShadow(al::LiveActor*)

auto isModeE3Rom() -> bool

auto isModeE3MovieRom() -> bool

auto isModeE3LiveRom() -> bool

auto isModeDiverRom() -> bool

auto isModeJungleGymRom() -> bool

auto isModeDiverOrJungleGymRom() -> bool

auto isModeMovieRom() -> bool

auto isModeEpdMovieRom() -> bool

void changeSeparatePlayMode(al::Scene*, bool)

void setSeparatePlayMode(al::Scene*, bool)

auto isTriggerUiDecide(const al::IUseSceneObjHolder*) -> bool

auto isTriggerUiDecide(const GameDataHolder*) -> bool

auto isTriggerUiCancel(const al::IUseSceneObjHolder*) -> bool

auto isTriggerUiSelect(const al::IUseSceneObjHolder*) -> bool

auto isTriggerUiPause(const al::IUseSceneObjHolder*) -> bool

auto isTriggerUiLeft(const al::IUseSceneObjHolder*) -> bool

auto isTriggerUiRight(const al::IUseSceneObjHolder*) -> bool

auto isTriggerUiUp(const al::IUseSceneObjHolder*) -> bool

auto isTriggerUiDown(const al::IUseSceneObjHolder*) -> bool

auto isTriggerUiR(const al::IUseSceneObjHolder*) -> bool

auto isTriggerUiL(const al::IUseSceneObjHolder*) -> bool

auto isTriggerUiZR(const al::IUseSceneObjHolder*) -> bool

auto isTriggerUiZL(const al::IUseSceneObjHolder*) -> bool

auto isTriggerUiX(const al::IUseSceneObjHolder*) -> bool

auto isTriggerUiY(const al::IUseSceneObjHolder*) -> bool

auto isTriggerUiAnyABXY(const al::IUseSceneObjHolder*) -> bool

auto isRepeatUiUp(const al::IUseSceneObjHolder*) -> bool

auto isRepeatUiDown(const al::IUseSceneObjHolder*) -> bool

auto isRepeatUiRight(const al::IUseSceneObjHolder*) -> bool

auto isRepeatUiLeft(const al::IUseSceneObjHolder*) -> bool

auto isHoldUiDecide(const al::IUseSceneObjHolder*) -> bool

auto isHoldUiCancel(const al::IUseSceneObjHolder*) -> bool

auto isHoldUiSelect(const al::IUseSceneObjHolder*) -> bool

auto isHoldUiL(const al::IUseSceneObjHolder*) -> bool

auto isHoldUiR(const al::IUseSceneObjHolder*) -> bool

auto isHoldUiY(const al::IUseSceneObjHolder*) -> bool

auto isHoldUiUp(const al::IUseSceneObjHolder*) -> bool

auto isHoldUiDown(const al::IUseSceneObjHolder*) -> bool

auto isHoldUiLeft(const al::IUseSceneObjHolder*) -> bool

auto isHoldUiRight(const al::IUseSceneObjHolder*) -> bool

auto isHoldSeparatePlayStart1P(const al::IUseSceneObjHolder*) -> bool

auto isHoldSeparatePlayStart2P(const al::IUseSceneObjHolder*) -> bool

auto isTriggerMapOpen(const al::IUseSceneObjHolder*) -> bool

auto isHoldSeparatePlayEnd(const al::IUseSceneObjHolder*) -> bool

auto getUiLeftStick(const al::IUseSceneObjHolder*) -> const sead::Vector2f&

auto getUiRightStick(const al::IUseSceneObjHolder*) -> const sead::Vector2f&

auto isTriggerMapClose(const al::IUseSceneObjHolder*) -> bool

auto isTriggerCollectionListOpenInMap(const al::IUseSceneObjHolder*) -> bool

auto isTriggerCollectionListCloseInMap(const al::IUseSceneObjHolder*) -> bool

auto isTriggerAppearSkipGuide(const al::IUseSceneObjHolder*) -> bool

auto isTriggerUiRacePause(const al::IUseSceneObjHolder*) -> bool

auto isTriggerSnapShotMode(const al::IUseSceneObjHolder*) -> bool

auto isTriggerAmiiboMode(const al::IUseSceneObjHolder*) -> bool

auto isHoldAmiiboMode(const al::IUseSceneObjHolder*) -> bool

auto isTriggerToggleSnapShotModeLayout(const al::IUseSceneObjHolder*) -> bool

auto isTriggerAppearSnapShotLayout(const al::IUseSceneObjHolder*) -> bool

auto isTriggerIncrementPostProcessingFilterPreset(const al::IUseSceneObjHolder*) -> bool

auto isTriggerDecrementPostProcessingFilterPreset(const al::IUseSceneObjHolder*) -> bool

void recordGamePadPlayStyleInfo(GamePadPlayStyleInfo*, const al::LiveActor*)

void recordGamePadPlayStyleInfo(GamePadPlayStyleInfo*, const al::LayoutActor*)

auto tryUpdateGamePadPlayStyleInfo(GamePadPlayStyleInfo*, const al::LiveActor*) -> bool

auto tryUpdateGamePadPlayStyleInfo(GamePadPlayStyleInfo*, const al::LayoutActor*) -> bool

auto searchNpcMessage(const al::ActorInitInfo&, const al::LayoutActor*) -> const char16*

void makeActorMessageLabel(sead::BufferedSafeString*, const al::ActorInitInfo&, const char*)

void makeMessageLabel(sead::BufferedSafeString*, const al::PlacementInfo&, const char*)

void makeMessageLabel(sead::BufferedSafeString*, const al::PlacementId*, const char*)

void setPaneStageMessageActorLabel(al::LayoutActor*, const char*, const al::ActorInitInfo&, const char*)

auto trySetPaneStageMessageIfExist(al::LayoutActor*, const char*, const char*, const char*) -> bool

auto getPlacementStageName(GameDataHolderAccessor, const al::ActorInitInfo&) -> const char*

auto getStageMessageActorLabel(al::LayoutActor*, const al::ActorInitInfo&, const char*) -> const char16*

auto isExistLabelInSystemMessageWithFileName(const al::IUseMessageSystem*, const char*, const char*) -> bool

auto isExistLabelInStageMessageWithFileName(const al::IUseMessageSystem*, const char*, const char*) -> bool

auto trySetPaneSystemMessageIfExist(al::LayoutActor*, const char*, const char*, const char*) -> bool

auto trySetPaneStringCheckpos32Name(al::LayoutActor*, const char*, s32, const char*) -> bool

auto getCheckpointLabelPrefix() -> const char*

void setPaneStringWorldNameForWorldMap(al::LayoutActor*, const char*, s32)

void setPaneStringWorldNameForWorldMapWithoutRuby(al::LayoutActor*, const char*, s32)

void setRaceRecordMessage(al::LayoutActor*, const char*, s32)

void setRaceRecordMessageCsec(al::LayoutActor*, const char*, s32)

void replaceRaceRecordMessageCsec(al::LayoutActor*, const char*, s32, const char16*, const char*)

void setRaceNoRecordMessage(al::LayoutActor*, const char*)

void setMiniGameNoCountMessage(al::LayoutActor*, const char*)

auto getWorldShinePictureFont(const al::LayoutActor*, s32, bool) -> const char16*

auto getNullShinePictureFont(const al::LayoutActor*) -> const char16*

auto getWorldCoinCollectPictureFont(const al::LayoutActor*, s32) -> const char16*

auto getWorldCoinCollectPictureFont(const al::LayoutActor*) -> const char16*

auto getPlacementStageName(GameDataHolderAccessor, const al::PlacementInfo&) -> const char*

auto getCollectBgmMessage(const al::IUseMessageSystem*, const CollectBgm*) -> const char16*

void setPaneCurrentCoinNum(al::LayoutActor*)

auto tryGetMapMainScenarioLabel(sead::BufferedSafeString*, sead::BufferedSafeString*, bool*, const al::IUseSceneObjHolder*) -> bool

auto isOnSwitchLinkSave(const al::LiveActor* actor, const al::ActorInitInfo& actorInitInfo) -> bool

auto isSaveSwitch(const al::ActorInitInfo& actorInitInfo) -> bool

void registerLayoutTextureRenderObj(al::IUseSceneObjHolder* user, al::LayoutTextureRenderObj* renderObj)

auto checkTimeReverseAndRestore(u64*, u64) -> bool

auto isSensorTypeYoshiEnableSendPush(const al::HitSensor* sensor) -> bool

auto isSensorTypeYoshiMsgReceivable(const al::HitSensor* sensor) -> bool

auto isInPuddleHeight(const al::WaterSurfaceFinder* surfaceFinder, const PlayerConst* playerConst) -> bool

auto tryCalcTonguePullPose(sead::Quatf* pose, const al::LiveActor* actor, const YoshiTongue* yoshiTongue) -> bool

auto findClingGroundPos(sead::Vector3f* pos, const al::LiveActor* actor, const sead::Vector3f&, f32) -> bool

Variables

const sead::Vector3f sItemOffset

Typedef documentation

typedef bool(*rs::break_judge_function_t)(const al::SensorMsg*)

#include <Util/BreakJudgeUtil.h>

Function documentation

void rs::resetHelpAmiiboState(const al::IUseSceneObjHolder* objHolder)

#include <Amiibo/HelpAmiiboDirector.h>

bool rs::isHelpAmiiboMode(const al::IUseSceneObjHolder* objHolder)

#include <Amiibo/HelpAmiiboDirector.h>

EnemyCap* rs::tryCreateEnemyCap(al::LiveActor* actor, const al::ActorInitInfo& info)

#include <Enemy/EnemyCap.h>

EnemyCap* rs::tryCreateEnemyCap(al::LiveActor* actor, const al::ActorInitInfo& info, const char* archiveName)

#include <Enemy/EnemyCap.h>

EnemyCap* rs::tryCreateEnemyCapSuffix(al::LiveActor* actor, const al::ActorInitInfo& info, const char* archiveName, const char* suffix)

#include <Enemy/EnemyCap.h>

bool rs::tryStartEnemyCapBlowDown(EnemyCap* cap, const al::HitSensor* sensor)

#include <Enemy/EnemyCap.h>

bool rs::tryStartEnemyCapBlowDown(EnemyCap* cap)

#include <Enemy/EnemyCap.h>

bool rs::tryAppearEnemyCap(EnemyCap* cap)

#include <Enemy/EnemyCap.h>

bool rs::isOnEnemyCap(EnemyCap* cap)

#include <Enemy/EnemyCap.h>

CoinCollectHolder* rs::createCoinCollectHolder(const al::IUseSceneObjHolder* objHolder)

#include <Item/CoinCollectHolder.h>

CoinCollectWatcher* rs::createCoinCollectWatcher(const al::IUseSceneObjHolder* objHolder)

#include <Item/CoinCollectWatcher.h>

void rs::setKidsModeLayoutDisable(const al::IUseSceneObjHolder* user)

#include <Layout/KidsModeLayoutAccessor.h>

void rs::setKidsModeLayoutEnable(const al::IUseSceneObjHolder* user)

#include <Layout/KidsModeLayoutAccessor.h>

bool rs::isKidsModeLayoutDisable(const al::IUseSceneObjHolder* user)

#include <Layout/KidsModeLayoutAccessor.h>

void rs::calcTransOnMap(sead::Vector2f*, const sead::Vector3f&, const sead::Matrix44f&, const sead::Vector2f&, f32, f32)

#include <Layout/MapLayout.h>

bool rs::tryCalcMapNorthDir(sead::Vector3f*, const al::IUseSceneObjHolder*)

#include <Layout/MapLayout.h>

const sead::Matrix44f& rs::getMapViewProjMtx(const al::IUseSceneObjHolder*)

#include <Layout/MapLayout.h>

const sead::Matrix44f& rs::getMapProjMtx(const al::IUseSceneObjHolder*)

#include <Layout/MapLayout.h>

void rs::appearMapWithHint(const al::IUseSceneObjHolder*)

#include <Layout/MapLayout.h>

void rs::addAmiiboHintToMap(const al::IUseSceneObjHolder*)

#include <Layout/MapLayout.h>

void rs::appearMapWithAmiiboHint(const al::IUseSceneObjHolder*)

#include <Layout/MapLayout.h>

void rs::appearMapMoonRockDemo(const al::IUseSceneObjHolder*, s32)

#include <Layout/MapLayout.h>

void rs::endMap(const al::IUseSceneObjHolder*)

#include <Layout/MapLayout.h>

bool rs::isEndMap(const al::IUseSceneObjHolder*)

#include <Layout/MapLayout.h>

bool rs::isEnableCheckpointWarp(const al::IUseSceneObjHolder*)

#include <Layout/MapLayout.h>

bool rs::tryShowCapMsgCollectCoinGetFirst(const al::IUseSceneObjHolder*)

#include <MapObj/CapMessageShowInfo.h>

void rs::validateGlideBirdOnPlayerNose(const al::LiveActor* player)

#include <Npc/BirdPlayerGlideCtrl.h>

void rs::invalidateGlideBirdOnPlayerNose(const al::LiveActor* player)

#include <Npc/BirdPlayerGlideCtrl.h>

void rs::validateGlideBirdOnSitDownPlayerHead(const al::LiveActor* player)

#include <Npc/BirdPlayerGlideCtrl.h>

void rs::invalidateGlideBirdOnSitDownPlayerHead(const al::LiveActor* player)

#include <Npc/BirdPlayerGlideCtrl.h>

bool rs::isPlayerSitDownChair(const Bird* bird)

#include <Npc/BirdPlayerGlideCtrl.h>

bool rs::isGuardNosePainCap(const al::LiveActor*)

#include <Player/Player.h>

bool rs::isSeparatePlay(const al::IUseSceneObjHolder*)

#include <Player/PlayerInputFunction.h>

void rs::calcGuidePos(sead::Vector3f*, const al::LiveActor*)

#include <Scene/GuidePosInfoHolder.h>

void rs::setRouteHeadGuidePosPtr(const al::IUseSceneObjHolder*, const sead::Vector3f*)

#include <Scene/GuidePosInfoHolder.h>

void rs::resetRouteHeadGuidePosPtr(const al::IUseSceneObjHolder*)

#include <Scene/GuidePosInfoHolder.h>

void rs::requestShowHtmlViewer(const al::IUseSceneObjHolder*)

#include <Scene/HtmlViewerRequester.h>

s32 rs::getActiveQuestNum(const al::IUseSceneObjHolder*)

#include <Scene/QuestInfoHolder.h>

s32 rs::getActiveQuestNo(const al::IUseSceneObjHolder*)

#include <Scene/QuestInfoHolder.h>

const char* rs::getActiveQuestLabel(const al::IUseSceneObjHolder*)

#include <Scene/QuestInfoHolder.h>

void rs::tryStartRaceStage(al::Scene*, GameDataHolder*)

#include <Scene/StageScene.h>

bool rs::updateNormalState(al::Scene*)

#include <Scene/StageScene.h>

void rs::updateEffectSystemEnv(al::Scene*)

#include <Scene/StageScene.h>

bool rs::updateNormalStateExcludeGraphics(al::Scene*)

#include <Scene/StageScene.h>

bool rs::updateBirdCarryMeat(al::Scene*)

#include <Scene/StageScene.h>

void rs::updateKitListExcludePlayer(al::Scene*)

#include <Scene/StageScene.h>

void rs::updateKitListExcludeCamera(al::Scene*)

#include <Scene/StageScene.h>

void rs::updateKitListExcludeCameraDemoChangeWorld(al::Scene*)

#include <Scene/StageScene.h>

void rs::updateKitListPlayerGroupNormal(al::Scene*)

#include <Scene/StageScene.h>

void rs::updateKitListDemoPlayerNoPauseEffect(al::Scene*)

#include <Scene/StageScene.h>

void rs::updateKitListDemoPlayerWithPauseEffect(al::Scene*)

#include <Scene/StageScene.h>

void rs::updateKitListDemoPlayerWithPauseEffectAndCalcAtEndClip(al::Scene*)

#include <Scene/StageScene.h>

void rs::updateKitListDemoNormalNoPauseEffect(al::Scene*)

#include <Scene/StageScene.h>

void rs::updateKitListDemoNormalWithPauseEffect(al::Scene*)

#include <Scene/StageScene.h>

void rs::updateKitListDemoCapWorldOpeninglWithPauseEffect(al::Scene*)

#include <Scene/StageScene.h>

void rs::updateKitListLayout(al::Scene*)

#include <Scene/StageScene.h>

void rs::updateKitListPostNoViewRenderer(al::Scene*)

#include <Scene/StageScene.h>

void rs::updateKitListLayoutIgnorePause(al::Scene*)

#include <Scene/StageScene.h>

void rs::updateKitListLayoutOnlyLayoutScene(al::Scene*)

#include <Scene/StageScene.h>

void rs::updateKitListPostWithPauseNormalEffectAndPlayerEffect(al::Scene*)

#include <Scene/StageScene.h>

void rs::updateKitListPostSnapShot(al::Scene*)

#include <Scene/StageScene.h>

void rs::setScenarioName(al::LayoutActor*, const al::Scene*)

#include <Scene/StageScene.h>

void rs::startTalkMsgTimeBalloonLayout(const al::Scene*)

#include <Scene/StageScene.h>

void rs::endPlayTalkMsgTimeBalloonLayout(const al::Scene*)

#include <Scene/StageScene.h>

void rs::endForceTalkMsgTimeBalloonLayout(const al::Scene*)

#include <Scene/StageScene.h>

void rs::changeDemoCommonProc(al::Scene*, ProjectItemDirector*)

#include <Scene/StageScene.h>

void rs::endDemoCommonProc(al::Scene*, ProjectItemDirector*)

#include <Scene/StageScene.h>

void rs::endDemoNormalShineGet(al::Scene*, ProjectItemDirector*)

#include <Scene/StageScene.h>

bool rs::tryOpenMap(al::IUseNerve*, const al::Scene*, const MapLayout*, const al::Nerve*)

#include <Scene/StageScene.h>

bool rs::tryChangeNextStage(GameDataHolder*, al::Scene*)

#include <Scene/StageScene.h>

al::LiveActor* rs::getPlayerActor(const al::Scene*)

#include <Scene/StageScene.h>

void rs::registerGraphicsPreset(const al::Scene*, const char*, const char*, const char*, bool)

#include <Scene/StageScene.h>

void rs::requestGraphicsPreset(const al::Scene*, const char*, const sead::Vector3f&)

#include <Scene/StageScene.h>

void rs::requestGraphicsCubeMap(const al::Scene*, const char*, const char*)

#include <Scene/StageScene.h>

void rs::requestGraphicsPresetAndCubeMap(const al::Scene*, const char*, const char*, const char*)

#include <Scene/StageScene.h>

void rs::requestGraphicsPresetAndCubeMap(const al::Scene*, const char*, const char*, const char*, const sead::Vector3f&)

#include <Scene/StageScene.h>

void rs::requestGraphicsPresetAndCubeMapFixedAngle(const al::Scene*, const char*, const char*, const char*)

#include <Scene/StageScene.h>

void rs::registerGraphicsPresetWorldMap(const al::Scene*)

#include <Scene/StageScene.h>

void rs::registerGraphicsPresetShop(const al::Scene*)

#include <Scene/StageScene.h>

void rs::registerGraphicsPresetMoonGet(const al::Scene*)

#include <Scene/StageScene.h>

void rs::registerGraphicsPresetCloset(const al::Scene*)

#include <Scene/StageScene.h>

void rs::registerGraphicsPresetPause(const al::Scene*)

#include <Scene/StageScene.h>

void rs::requestGraphicsPresetAndCubeMapWorldMap(const al::Scene*)

#include <Scene/StageScene.h>

void rs::requestGraphicsPresetAndCubeMapShop(const al::Scene*)

#include <Scene/StageScene.h>

void rs::requestGraphicsPresetAndCubeMapShopNoFixedAngle(const al::Scene*)

#include <Scene/StageScene.h>

void rs::requestGraphicsPresetAndCubeMapMoonGet(const al::Scene*)

#include <Scene/StageScene.h>

void rs::requestGraphicsPresetAndCubeMapMoonGetNoFixedAngle(const al::Scene*)

#include <Scene/StageScene.h>

void rs::requestGraphicsPresetAndCubeMapCloset(const al::Scene*)

#include <Scene/StageScene.h>

void rs::requestGraphicsPresetAndCubeMapClosetNoFixedAngle(const al::Scene*)

#include <Scene/StageScene.h>

void rs::requestGraphicsPresetAndCubeMapPause(const al::Scene*)

#include <Scene/StageScene.h>

void rs::requestGraphicsPresetAndCubeMapPauseNoFixedAngle(const al::Scene*)

#include <Scene/StageScene.h>

void rs::calcQuatPoseCheckpointWarpCap(sead::Quatf*, const sead::Vector3f&, const al::IUseCamera*)

#include <Scene/StageScene.h>

ProjectDemoDirector* rs::getDemoDirector(const al::Scene*)

#include <Scene/StageScene.h>

Shine* rs::getDemoShineActor(const al::Scene*)

#include <Scene/StageScene.h>

bool rs::isExistDemoShine(const al::Scene*)

#include <Scene/StageScene.h>

void rs::setSceneStatusBossBattle(const al::LiveActor* actor)

#include <Sequence/GameSequenceInfo.h>

void rs::setSceneStatusBossBattleEnd(const al::LiveActor* actor)

#include <Sequence/GameSequenceInfo.h>

void rs::setSceneStatusBossBattleEndForPlayerAnim(const al::LiveActor* actor)

#include <Sequence/GameSequenceInfo.h>

bool rs::isSceneStatusBossBattle(GameDataHolderAccessor accessor)

#include <Sequence/GameSequenceInfo.h>

bool rs::isSceneStatusBossBattleForPlayerAnim(const al::LiveActor* actor)

#include <Sequence/GameSequenceInfo.h>

bool rs::isSceneStatusInvalidSave(GameDataHolderAccessor accessor)

#include <Sequence/GameSequenceInfo.h>

void rs::setSceneStatusInvalidSave(GameDataHolderAccessor accessor)

#include <Sequence/GameSequenceInfo.h>

bool rs::isInvalidSaveStage(const char* stageName)

#include <Sequence/GameSequenceInfo.h>

bool rs::isWipeOpenEnd(const al::LiveActor* actor)

#include <Sequence/GameSequenceInfo.h>

void rs::endWipeOpen(const GameDataHolder* holder)

#include <Sequence/GameSequenceInfo.h>

void rs::startWipeOpen(const GameDataHolder* holder)

#include <Sequence/GameSequenceInfo.h>

bool rs::isShopStatusBuyItem(const al::LiveActor* actor)

#include <Sequence/GameSequenceInfo.h>

bool rs::isShopStatusBuyShine(const al::LiveActor* actor)

#include <Sequence/GameSequenceInfo.h>

bool rs::isShopStatusBuyShineMany(const al::LiveActor* actor)

#include <Sequence/GameSequenceInfo.h>

bool rs::isShopStatusBuyMaxLifeUpItem(const al::LiveActor* actor)

#include <Sequence/GameSequenceInfo.h>

void rs::setShopStatusBuyShine(const al::LiveActor* actor)

#include <Sequence/GameSequenceInfo.h>

void rs::setShopStatusBuyShineMany(const al::LiveActor* actor)

#include <Sequence/GameSequenceInfo.h>

void rs::setShopStatusBuyMaxLifeUpItem(const al::LiveActor* actor)

#include <Sequence/GameSequenceInfo.h>

void rs::setShopStatusNone(const al::LiveActor* actor)

#include <Sequence/GameSequenceInfo.h>

GameConfigData* rs::getGameConfigData(const al::LayoutActor*)

#include <System/GameConfigData.h>

void rs::saveGameConfigData(const al::LayoutActor*)

#include <System/GameConfigData.h>

void rs::applyGameConfigData(al::Scene*, const GameConfigData*)

#include <System/GameConfigData.h>

bool rs::isUseOpenListAdditionalButton(const al::IUseSceneObjHolder*)

#include <System/GameConfigData.h>

SaveObjInfo* rs::createSaveObjInfoWriteSaveData(const al::ActorInitInfo& actorInitInfo)

#include <System/GameDataUtil.h>

SaveObjInfo* rs::createSaveObjInfoWriteSaveData(const al::ActorInitInfo& actorInitInfo, const al::PlacementInfo& placementInfo)

#include <System/GameDataUtil.h>

SaveObjInfo* rs::createSaveObjInfoNoWriteSaveDataInSameWorld(const al::ActorInitInfo& actorInitInfo)

#include <System/GameDataUtil.h>

SaveObjInfo* rs::createSaveObjInfoNoWriteSaveDataInSameWorld(const al::ActorInitInfo& actorInitInfo, const al::PlacementInfo& placementInfo)

#include <System/GameDataUtil.h>

SaveObjInfo* rs::createSaveObjInfoNoWriteSaveDataInSameWorldResetMiniGame(const al::ActorInitInfo& actorInitInfo)

#include <System/GameDataUtil.h>

SaveObjInfo* rs::createSaveObjInfoNoWriteSaveDataInSameWorldResetMiniGame(const al::ActorInitInfo& actorInitInfo, const al::PlacementInfo& placementInfo)

#include <System/GameDataUtil.h>

SaveObjInfo* rs::createSaveObjInfoNoWriteSaveDataInSameScenario(const al::ActorInitInfo& actorInitInfo)

#include <System/GameDataUtil.h>

SaveObjInfo* rs::createSaveObjInfoNoWriteSaveDataInSameScenario(const al::ActorInitInfo& actorInitInfo, const al::PlacementInfo& placementInfo)

#include <System/GameDataUtil.h>

SaveObjInfo* rs::createSaveObjInfoWriteSaveData(const al::ActorInitInfo& actorInitInfo, const al::PlacementId* placementId)

#include <System/GameDataUtil.h>

SaveObjInfo* rs::createSaveObjInfoNoWriteSaveDataInSameWorld(const al::ActorInitInfo& actorInitInfo, const al::PlacementId* placementId)

#include <System/GameDataUtil.h>

SaveObjInfo* rs::createSaveObjInfoNoWriteSaveDataInSameWorldResetMiniGame(const al::ActorInitInfo& actorInitInfo, const al::PlacementId* placementId)

#include <System/GameDataUtil.h>

SaveObjInfo* rs::createSaveObjInfoNoWriteSaveDataInSameScenario(const al::ActorInitInfo& actorInitInfo, const al::PlacementId* placementId)

#include <System/GameDataUtil.h>

void rs::onSaveObjInfo(SaveObjInfo* saveObjInfo)

#include <System/GameDataUtil.h>

void rs::offSaveObjInfo(SaveObjInfo* saveObjInfo)

#include <System/GameDataUtil.h>

bool rs::isOnSaveObjInfo(const SaveObjInfo* saveObjInfo)

#include <System/GameDataUtil.h>

void rs::setGrowFlowerTime(const al::LiveActor* actor, const al::PlacementId*, const al::PlacementId*, u64 time)

#include <System/GameDataUtil.h>

void rs::setGrowFlowerTime(const al::LiveActor* actor, const al::PlacementId*, u64 time)

#include <System/GameDataUtil.h>

u64 rs::getGrowFlowerTime(const al::LiveActor* actor, const al::PlacementId*)

#include <System/GameDataUtil.h>

bool rs::isUsedGrowFlowerSeed(const al::LiveActor* actor, const al::PlacementId*)

#include <System/GameDataUtil.h>

void rs::addGrowFlowerGrowLevel(const al::LiveActor* actor, const al::PlacementId*, u32 growLevel)

#include <System/GameDataUtil.h>

u32 rs::getGrowFlowerGrowLevel(const al::LiveActor* actor, const al::PlacementId*)

#include <System/GameDataUtil.h>

const char* rs::findGrowFlowerPotIdFromSeedId(const al::LiveActor* actor, const al::PlacementId*)

#include <System/GameDataUtil.h>

bool rs::isPlayFirstTimeBalloon(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::playTimeBalloonFirst(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::onShortExplainGet(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::onShortExplainSet(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::isShortExplainGet(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::isShortExplainSet(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::onReactedLuigiCostume(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::isReactedLuigiCostume(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

s32 rs::getPlayerRank(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

s32 rs::getPlayerRank(GameDataHolderAccessor accessor)

#include <System/GameDataUtil.h>

void rs::setPlayerRank(const al::LiveActor* actor, s32 rank)

#include <System/GameDataUtil.h>

void rs::setPlayerRank(GameDataHolderAccessor accessor, s32 rank)

#include <System/GameDataUtil.h>

u64 rs::getPrincipalId(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::setPrincipalId(const al::LiveActor* actor, u64 principalId)

#include <System/GameDataUtil.h>

bool rs::isAnswerCorrectSphinxQuiz(GameDataHolderAccessor accessor, const char* worldName)

#include <System/GameDataUtil.h>

void rs::answerCorrectSphinxQuiz(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::isAnswerCorrectSphinxQuizAll(GameDataHolderAccessor accessor, const char* worldName)

#include <System/GameDataUtil.h>

void rs::answerCorrectSphinxQuizAll(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::isTalkAlreadyLocalLanguage(const NpcEventDirector* npcEventDirector)

#include <System/GameDataUtil.h>

void rs::talkLocalLanguage(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

const char* rs::getLocalLanguageName(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

const char* rs::getLocalLanguageName(const NpcEventDirector* npcEventDirector)

#include <System/GameDataUtil.h>

bool rs::isOnFlagKinopioBrigadeNpcFirstTalk(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::onFlagKinopioBrigadeNpcFirstTalk(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::isOnFlagHintNpcFirstTalk(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::onFlagHintNpcFirstTalk(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::playScenarioStartCamera(const al::LiveActor* actor, const QuestInfo* questInfo)

#include <System/GameDataUtil.h>

void rs::playScenarioStartCamera(const al::LiveActor* actor, s32 idx)

#include <System/GameDataUtil.h>

void rs::setExistKoopaShip(const KoopaShip* koopaShip)

#include <System/GameDataUtil.h>

void rs::resetExistKoopaShip(const KoopaShip* koopaShip)

#include <System/GameDataUtil.h>

bool rs::isExistKoopaShip(const ShineTowerRocket* shineTowerRocket)

#include <System/GameDataUtil.h>

bool rs::isExistKoopaShipInSky(const ShineTowerRocket* shineTowerRocket)

#include <System/GameDataUtil.h>

bool rs::tryUnlockShineName(const al::LiveActor* actor, s32 shineIdx)

#include <System/GameDataUtil.h>

void rs::calcShineIndexTableNameAvailable(s32*, s32*, const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::calcShineIndexTableNameUnlockable(s32*, s32*, const al::LiveActor* actor)

#include <System/GameDataUtil.h>

s32 rs::calcWorldIdByWorldWarpHole(const WorldWarpHole* worldWarpHole, const char* changeStageId)

#include <System/GameDataUtil.h>

bool rs::checkIsOpenWorldWarpHoleCurrentScenario(const WorldWarpHole* worldWarpHole)

#include <System/GameDataUtil.h>

bool rs::isKidsMode(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::isKidsMode(const al::LayoutActor* layout)

#include <System/GameDataUtil.h>

bool rs::isKidsMode(const al::Scene* scene)

#include <System/GameDataUtil.h>

bool rs::isKidsMode(const al::IUseSceneObjHolder* user)

#include <System/GameDataUtil.h>

bool rs::isKidsMode(const GameDataHolder* holder)

#include <System/GameDataUtil.h>

bool rs::isEnableCapMessageLifeOneKidsMode(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::disableCapMessageLifeOneKidsMode(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::isInvalidChangeStage(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::isSequenceTimeBalloonOrRace(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::isTreasureBoxDeadStage(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::findRaceRecord(bool* isExistRecord, bool*, s32* record, s32*, s32* lapRecord, const al::LiveActor* actor, const char* raceName)

#include <System/GameDataUtil.h>

void rs::findRaceRecord(bool* isExistRecord, bool*, s32* record, s32*, s32* lapRecord, const al::Scene* actor, const char* raceName)

#include <System/GameDataUtil.h>

void rs::findRaceRecordRaceManRace(bool* isExistRecord, bool*, s32* record, s32*, s32* lapRecord, const al::Scene* scene)

#include <System/GameDataUtil.h>

void rs::findRaceRecordRaceManRace(bool* isExistRecord, bool*, s32* record, s32*, s32* lapRecord, const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::findRaceRecordRaceManRaceWithWorldId(bool* isExistRecord, bool*, s32* record, s32*, s32* lapRecord, const al::Scene* scene, s32 worldId)

#include <System/GameDataUtil.h>

void rs::findRaceRecordRaceManRaceWithWorldId(bool* isExistRecord, bool*, s32* record, s32*, s32* lapRecord, const al::LiveActor* actor, s32 worldId)

#include <System/GameDataUtil.h>

void rs::findRaceRecordRadicon(bool* isExistRecord, bool*, s32* record, s32*, s32* lapRecord, const al::Scene* scene)

#include <System/GameDataUtil.h>

void rs::findRaceRecordRadicon(bool* isExistRecord, bool*, s32* record, s32*, s32* lapRecord, const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::findRaceRecordYukimaru(bool* isExistRecord, bool*, s32* record, s32*, s32* lapRecord, const al::Scene* scene, s32 level)

#include <System/GameDataUtil.h>

void rs::findRaceRecordYukimaru(bool* isExistRecord, bool*, s32* record, s32*, s32* lapRecord, const al::LiveActor* actor, s32 level)

#include <System/GameDataUtil.h>

void rs::writeRaceRecord(const al::LiveActor* actor, const char* raceName, s32 record, s32, s32 lapRecord)

#include <System/GameDataUtil.h>

void rs::writeRaceRecord(const al::Scene* scene, const char* raceName, s32 record, s32, s32 lapRecord)

#include <System/GameDataUtil.h>

s32 rs::getJumpingRopeBestCount(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

s32 rs::getJumpingRopeBestCount(const al::Scene* scene)

#include <System/GameDataUtil.h>

void rs::setJumpingRopeBestCount(const al::LiveActor* actor, s32 count)

#include <System/GameDataUtil.h>

void rs::setJumpingRopeBestCount(const al::Scene* scene, s32 count)

#include <System/GameDataUtil.h>

s32 rs::getJumpingRopeDayCount(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::setJumpingRopeDayCount(const al::LiveActor* actor, s32 count)

#include <System/GameDataUtil.h>

void rs::setJumpingRopeUpdateScoreFlag(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::isExistRecordJumpingRope(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::isExistRecordJumpingRope(const al::Scene* scene)

#include <System/GameDataUtil.h>

bool rs::isExistRecordInDayJumpingRope(const al::LayoutActor* layout)

#include <System/GameDataUtil.h>

s32 rs::getVolleyballBestCount(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

s32 rs::getVolleyballBestCount(const al::Scene* scene)

#include <System/GameDataUtil.h>

void rs::setVolleyballBestCount(const al::LiveActor* actor, s32 count)

#include <System/GameDataUtil.h>

void rs::setVolleyballBestCount(const al::Scene* scene, s32 count)

#include <System/GameDataUtil.h>

s32 rs::getVolleyballDayCount(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::setVolleyballDayCount(const al::LiveActor* actor, s32 count)

#include <System/GameDataUtil.h>

void rs::setVolleyballUpdateScoreFlag(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::isExistRecordVolleyball(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::isExistRecordVolleyball(const al::Scene* scene)

#include <System/GameDataUtil.h>

bool rs::isExistRecordInDayVolleyball(const al::LayoutActor* layout)

#include <System/GameDataUtil.h>

void rs::writeRaceRecordRaceManRace(const al::LiveActor* actor, s32 record)

#include <System/GameDataUtil.h>

bool rs::isTalkFirstAmiiboNpc(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::offFlagTalkFirstAmiiboNpc(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::checkGetShineForWorldTravelingPeach(GameDataHolderAccessor accessor, const char* worldName)

#include <System/GameDataUtil.h>

bool rs::checkEnableAppearMoonWorldTravelingPeach(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::isStartWorldTravelingPeach(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::startWorldTravelingPeach(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::checkGetEnoughShine(const al::LiveActor* actor, s32 count)

#include <System/GameDataUtil.h>

bool rs::checkGetEnoughShineInCurrentWorld(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::setFlagOnStartKoopaCapture(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::isStartKoopaCapture(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::isAlreadyTalkPrevWorldInWorldWarp(const al::LiveActor* actor, s32)

#include <System/GameDataUtil.h>

bool rs::isAlreadyTalkNextWorldInWorldWarp(const al::LiveActor* actor, s32)

#include <System/GameDataUtil.h>

void rs::setAlreadyTalkPrevWorldInWorldWarp(const al::LiveActor* actor, s32)

#include <System/GameDataUtil.h>

void rs::setAlreadyTalkNextWorldInWorldWarp(const al::LiveActor* actor, s32)

#include <System/GameDataUtil.h>

bool rs::checkNeedTalkPrevWorld(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

s32 rs::getTipsIdInWorldWarp(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::addTipsIdInWorldWarp(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::setTalkSpecialInWorldWarp(const al::LiveActor* actor, bool, bool)

#include <System/GameDataUtil.h>

bool rs::isTalkFindKoopaInWorldWarp(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::isTalkBossRaidInWorldWarp(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::isClearMainScenario(const al::LiveActor* actor, s32 worldId)

#include <System/GameDataUtil.h>

bool rs::checkAlreadyVisitStage(const GameDataHolder* holder, const char* stageName)

#include <System/GameDataUtil.h>

void rs::visitStage(const GameDataHolder* holder, const char* stageName)

#include <System/GameDataUtil.h>

bool rs::isSequenceGoToNextWorld(const al::IUseSceneObjHolder* user)

#include <System/GameDataUtil.h>

bool rs::isSequenceCollectShineBeforeGameClear(const al::IUseSceneObjHolder* user)

#include <System/GameDataUtil.h>

bool rs::isSequenceCollectShineForRepairHome(const al::IUseSceneObjHolder* user)

#include <System/GameDataUtil.h>

bool rs::isSequenceCollectShine(const al::IUseSceneObjHolder* user)

#include <System/GameDataUtil.h>

bool rs::isSequenceGoToMoonRock(const al::IUseSceneObjHolder* user)

#include <System/GameDataUtil.h>

bool rs::isEnableExplainShopCoin(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::explainShopCoin(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::checkShowNewItemAndPrepareSave(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::isInNormalCoinShopFirst(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::offInNormalCoinShopFirst(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::checkExistNewShopItem(const al::LiveActor* actor, s32, s32, bool)

#include <System/GameDataUtil.h>

CapMessageBossData* rs::getCapMessageBossData(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::getYoshiFruit(SaveObjInfo* saveObjInfo)

#include <System/GameDataUtil.h>

bool rs::isGetYoshiFruit(const SaveObjInfo* saveObjInfo)

#include <System/GameDataUtil.h>

bool rs::isTalkKakku(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::talkKakku(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::isTalkWorldTravelingPeach(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::talkWorldTravelingPeach(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::isTalkCollectBgmNpc(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::talkCollectBgmNpc(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

s32 rs::getTokimekiMayorNpcFavorabilityRating(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::setTokimekiMayorNpcFavorabilityRating(const al::LiveActor* actor, s32 rating)

#include <System/GameDataUtil.h>

bool rs::tryFindCoinStackSave(s32*, const al::LiveActor* actor, const al::PlacementId*)

#include <System/GameDataUtil.h>

void rs::saveCoinStack(const al::LiveActor* actor, const al::PlacementId*, s32)

#include <System/GameDataUtil.h>

bool rs::isCollectedBgmCityWorldCelemony(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::isCollectedBgmCityWorldCelemony2D(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

s32 rs::calcGetShineNumCollectedBgm(GameDataHolderAccessor accessor)

#include <System/GameDataUtil.h>

bool rs::checkGetShineCollectedBgmAll(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::checkSavedHintPhoto(const al::LiveActor* actor, const char* name)

#include <System/GameDataUtil.h>

void rs::saveHintPhoto(const al::LiveActor* actor, const char* name)

#include <System/GameDataUtil.h>

bool rs::isRideSphinx(GameDataHolderAccessor accessor)

#include <System/GameDataUtil.h>

void rs::rideSphinx(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

bool rs::isRideMotorcycle(GameDataHolderAccessor accessor)

#include <System/GameDataUtil.h>

void rs::rideMotorcycle(const al::LiveActor* actor)

#include <System/GameDataUtil.h>

void rs::setShowInformationPoleGrab(const al::IUseSceneObjHolder* user)

#include <System/GameDataUtil.h>

bool rs::isNeedShowInformationPoleGrab(const al::IUseSceneObjHolder* user)

#include <System/GameDataUtil.h>

void rs::setShowInformationPoleClimb(const al::IUseSceneObjHolder* user)

#include <System/GameDataUtil.h>

bool rs::isNeedShowInformationPoleClimb(const al::IUseSceneObjHolder* user)

#include <System/GameDataUtil.h>

void rs::setShowInformationPoleClimbTop(const al::IUseSceneObjHolder* user)

#include <System/GameDataUtil.h>

bool rs::isNeedShowInformationPoleClimbTop(const al::IUseSceneObjHolder* user)

#include <System/GameDataUtil.h>

bool rs::isNeedConfirmNetworkFirst(const al::IUseSceneObjHolder* user)

#include <System/GameDataUtil.h>

void rs::saveConfirmNetworkFirst(const al::IUseSceneObjHolder* user)

#include <System/GameDataUtil.h>

MapData* rs::findMapData(al::IUseSceneObjHolder*, s32)

#include <System/MapDataHolder.h>

const char16* rs::getAchievementName(const al::IUseMessageSystem* user, const char* label)

#include <Util/AchievementUtil.h>

const char16* rs::getAchievementName(const al::LayoutActor* layout, s32 achievementIdx)

#include <Util/AchievementUtil.h>

const char16* rs::getAchievementHint(const al::IUseMessageSystem* user, const char* label)

#include <Util/AchievementUtil.h>

const char16* rs::getAchievementHint(const al::LayoutActor* layout, s32 achievementIdx)

#include <Util/AchievementUtil.h>

AchievementHolder* rs::getAchievementHolder(const al::LayoutActor* layout)

#include <Util/AchievementUtil.h>

void rs::unlockAchievementShineName(GameDataHolderAccessor accessor)

#include <Util/AchievementUtil.h>

bool rs::isUnlockAchievementShineName(GameDataHolderAccessor accessor)

#include <Util/AchievementUtil.h>

bool rs::checkGetAchievement(GameDataHolderAccessor accessor, const char* label)

#include <Util/AchievementUtil.h>

bool rs::checkGetAchievement(const al::LayoutActor* layout, s32 achievementIdx)

#include <Util/AchievementUtil.h>

sead::DateTime rs::findAchievementGetTime(const al::LayoutActor* layout, s32 achievementIdx)

#include <Util/AchievementUtil.h>

sead::DateTime rs::findAchievementGetTime(const al::LayoutActor* layout, const char* label)

#include <Util/AchievementUtil.h>

sead::Vector3f* rs::findAchievementTrans(const al::LayoutActor* layout, s32 achievementIdx)

#include <Util/AchievementUtil.h>

s32 rs::getAchievementNum(const al::LayoutActor* layout)

#include <Util/AchievementUtil.h>

s32 rs::calcReceivedAchievementNum(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::getTotalCoinNum(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::calcWorldWarpHoleThroughNum(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::getWorldWarpHoleThroughNumMax(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::calcGetCheckpointNum(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::calcBuyItemNumForCoinCollectByWorld(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::calcClearWorldNum(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

void rs::addPlayerJumpCount(const al::LiveActor* actor)

#include <Util/AchievementUtil.h>

s32 rs::getPlayerJumpCount(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

void rs::addPlayerThrowCapCount(const al::LiveActor* actor)

#include <Util/AchievementUtil.h>

s32 rs::getPlayerThrowCapCount(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

bool rs::checkGetCoinCollectAllInWorld(const al::LiveActor* actor, s32 worldId)

#include <Util/AchievementUtil.h>

bool rs::checkGetCoinCollectHalfInWorld(const AchievementNpc* achievementNpc, s32 worldId)

#include <Util/AchievementUtil.h>

bool rs::checkGetShineAllInWorld(const AchievementNpc* achievementNpc, s32 worldId)

#include <Util/AchievementUtil.h>

bool rs::checkGetClothAndCapNum(const AchievementNpc* achievementNpc, s32 num)

#include <Util/AchievementUtil.h>

bool rs::checkUnlockMoonRockAllWorld(GameDataHolderAccessor accessor)

#include <Util/AchievementUtil.h>

s32 rs::calcUnlockMoonRockNum(GameDataHolderAccessor accessor)

#include <Util/AchievementUtil.h>

s32 rs::calcHackObjNum(GameDataHolderAccessor accessor)

#include <Util/AchievementUtil.h>

s32 rs::calcSphinxQuizCompleteNum(GameDataHolderAccessor accessor)

#include <Util/AchievementUtil.h>

s32 rs::calcGetShineNumDot(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::calcGetShineNumTreasureBox(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::calcGetShineNumNoteObj(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::calcGetShineNumTimerAthletic(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::calcGetShineNumKinopioBrigade(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::calcGetShineNumWorldTravelingPeach(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::calcGetShineNumCollectAnimal(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::calcAllShineNumCollectAnimal(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::calcGetShineNumKuriboGirl(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::calcGetShineNumJugemFish(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::calcGetShineNumGrowPlant(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::calcGetShineNumRabbit(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::calcGetShineNumDigPoint(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::calcGetShineNumCapHanger(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::calcGetShineNumBird(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::calcGetShineNumCostumeRoom(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::calcGetShineNumSlot(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::calcGetShineNumRace(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::calcGetShineNumFigureWalking(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::calcGetShineNumHideAndSeekCapMan(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::calcAllShineNumHideAndSeekCapMan(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::calcGetShineNumCollectBgmNpc(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::calcAllShineNumCollectBgmNpc(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

s32 rs::calcGetShineNumHintPhoto(const GameDataHolder* holder)

#include <Util/AchievementUtil.h>

ActorDimensionKeeper* rs::createDimensionKeeper(const al::LiveActor* actor)

#include <Util/ActorDimensionKeeper.h>

bool rs::is2D(const IUseDimension* dimension)

#include <Util/ActorDimensionKeeper.h>

bool rs::is3D(const IUseDimension* dimension)

#include <Util/ActorDimensionKeeper.h>

bool rs::isChange2D(const IUseDimension* dimension)

#include <Util/ActorDimensionKeeper.h>

bool rs::isChange3D(const IUseDimension* dimension)

#include <Util/ActorDimensionKeeper.h>

bool rs::isIn2DArea(const IUseDimension* dimension)

#include <Util/ActorDimensionKeeper.h>

void rs::updateDimensionKeeper(ActorDimensionKeeper* keeper)

#include <Util/ActorDimensionKeeper.h>

const char* rs::getSpecialPurposeName2DOnly()

#include <Util/ActorDimensionKeeper.h>

void rs::createAndSetFilter2DOnly(al::LiveActor* actor)

#include <Util/ActorDimensionKeeper.h>

al::CollisionPartsFilterOnlySpecialPurpose* rs::createCollisionPartsFilter2DOnly()

#include <Util/ActorDimensionKeeper.h>

void rs::snap2D(al::LiveActor* actor, const IUseDimension* dimension, f32 unk_distance)

#include <Util/ActorDimensionKeeper.h>

void rs::snap2DGravity(al::LiveActor* actor, const IUseDimension* dimension, f32 unk_distance)

#include <Util/ActorDimensionKeeper.h>

void rs::snap2DParallelizeFront(al::LiveActor*, const IUseDimension*, f32)

#include <Util/ActorDimensionUtil.h>

void rs::calcSearchAmiiboBit(s32* gameId, s32* characterId, s32* characterVariant, s32 characterIdS32)

#include <Util/AmiiboUtil.h>

s32 rs::createCharacterIdS32(const al::NfpCharacterId& characterId)

#include <Util/AmiiboUtil.h>

bool rs::isEnableUseStageSceneAmiibo(const al::NfpInfo& nfpInfo)

#include <Util/AmiiboUtil.h>

bool rs::isExistAmiiboMstxtData(const al::IUseMessageSystem* user, const al::NfpInfo& nfpInfo)

#include <Util/AmiiboUtil.h>

al::StringTmp<64> rs::getAmiiboMstxtLabel(bool*, const al::IUseMessageSystem* user, s32, s32, s32)

#include <Util/AmiiboUtil.h>

void rs::tryFindAmiiboCostumeItemInfo(ShopItem::ItemInfo**, ShopItem::ItemInfo**, const al::NfpCharacterId& characterId, s32, al::IUseSceneObjHolder* user)

#include <Util/AmiiboUtil.h>

void rs::resetHelpAmiibo(const al::IUseSceneObjHolder* user)

#include <Util/AmiiboUtil.h>

SearchAmiiboDataTable* rs::getSearchAmiiboData(const al::IUseSceneObjHolder* user)

#include <Util/AmiiboUtil.h>

void rs::appearCoinCollectHintEffect(const al::IUseSceneObjHolder* user)

#include <Util/AmiiboUtil.h>

void rs::killCoinCollectHintEffect(const al::IUseSceneObjHolder* user)

#include <Util/AmiiboUtil.h>

al::AreaObj* rs::tryFind2DAreaObj(const al::IUseAreaObj* user, const sead::Vector3f& trans)

#include <Util/AreaUtil.h>

al::AreaObj* rs::tryFind2DAreaObj(const al::LiveActor* actor, sead::Vector3f*, sead::Vector3f*)

#include <Util/AreaUtil.h>

void rs::calc2DAreaLockDir(sead::Vector3f* lockDir, const al::AreaObj* area, const sead::Vector3f& trans)

#include <Util/AreaUtil.h>

void rs::get2DAreaPos(sead::Vector3f* pos, const al::AreaObj* area)

#include <Util/AreaUtil.h>

bool rs::isIn2DArea(const al::LiveActor* actor, sead::Vector3f*, sead::Vector3f*)

#include <Util/AreaUtil.h>

bool rs::isInChangeStage(const al::LiveActor* actor, const sead::Vector3f* trans)

#include <Util/AreaUtil.h>

bool rs::isInWarpArea(const al::LiveActor* actor)

#include <Util/AreaUtil.h>

bool rs::isInLowGravityArea(const al::LiveActor* actor)

#include <Util/AreaUtil.h>

bool rs::isInItemVanishArea(const al::LiveActor* actor)

#include <Util/AreaUtil.h>

bool rs::tryFindStageMapAreaAndGetPlayerPoint(sead::Vector3f* playerPoint, const al::IUseAreaObj* user, const sead::Vector3f& trans)

#include <Util/AreaUtil.h>

bool rs::calcFindWaterAreaSurfaceNoWaveByArrow(const al::LiveActor* actor, sead::Vector3f*, sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&)

#include <Util/AreaUtil.h>

bool rs::isPushOut2DAreaOpposite(const al::AreaObj* area)

#include <Util/AreaUtil.h>

bool rs::isFaceTo2DAreaPushOutDir(const al::AreaObj* area)

#include <Util/AreaUtil.h>

void rs::calc2DAreaFreeDir(sead::Vector3f* freeDir, const al::AreaObj* area, const sead::Vector3f& trans)

#include <Util/AreaUtil.h>

bool rs::calc2DAreaGravity(sead::Vector3f* gravity, const al::AreaObj* area, const sead::Vector3f& trans)

#include <Util/AreaUtil.h>

bool rs::calc2DAreaSnapPower(sead::Vector3f*, f32* snapPower, const al::AreaObj* area, const sead::Vector3f& trans)

#include <Util/AreaUtil.h>

bool rs::calc2DAreaDistanceGravity(sead::Vector3f*, const al::AreaObj* area, const sead::Vector3f& trans)

#include <Util/AreaUtil.h>

f32 rs::get2DAreaSurfaceDistance(const al::AreaObj* area)

#include <Util/AreaUtil.h>

bool rs::calc2DAreaSnapPowerSurfaceDistance(sead::Vector3f*, f32* snapPower, const al::AreaObj* area, const sead::Vector3f& trans, f32 surfaceDistance)

#include <Util/AreaUtil.h>

bool rs::calcExtForceAreaVelocity(sead::Vector3f*, const al::IUseAreaObj* user, const sead::Vector3f& trans, const sead::Vector3f&, const sead::Vector3f& velocity)

#include <Util/AreaUtil.h>

bool rs::tryFindRecoveryTargetPosArea(bool* isNoCollideGround, sead::Vector3f* targetPos, sead::Vector3f* targetRotate, const al::AreaObj** area, const al::IUseAreaObj* user, const sead::Vector3f& trans)

#include <Util/AreaUtil.h>

bool rs::tryFindForceRecoveryArea(sead::Vector3f* targetPos, sead::Vector3f* targetRotate, const al::AreaObj** area, const al::IUseAreaObj* user, const sead::Vector3f& trans)

#include <Util/AreaUtil.h>

break_judge_function_t rs::getBreakJudgeFunction(const char* name)

#include <Util/BreakJudgeUtil.h>

bool rs::isEnableStartSubjectiveCamera(const al::LiveActor* actor)

#include <Util/CameraUtil.h>

al::CameraTicket* rs::initFollowLimitCamera(const al::IUseCamera* user, const al::ActorInitInfo& actorInitInfo, const char*)

#include <Util/CameraUtil.h>

al::CameraTicket* rs::initParallel2DCamera(const al::IUseCamera* user, const al::ActorInitInfo& actorInitInfo, const char*)

#include <Util/CameraUtil.h>

void rs::invalidateFollowLimitCameraAutoResetLowAngleV(al::CameraTicket* ticket)

#include <Util/CameraUtil.h>

void rs::updateCameraPosFromDistanceAndAngleHV(sead::Vector3f* newPos, const sead::Vector3f& cameraPos, f32 distance, f32 angleY, f32 angleH)

#include <Util/CameraUtil.h>

bool rs::isPreCameraFollowOrParallel(const al::CameraStartInfo& cameraStartInfo)

#include <Util/CameraUtil.h>

al::CameraTicket* rs::initGetMoonCamera(const al::IUseCamera* user, const al::LiveActor* moon, const al::ActorInitInfo& actorInitInfo, const char* name, sead::Vector3f*, sead::Vector3f*, sead::Vector3f*, sead::LookAtCamera* lookAtCamera)

#include <Util/CameraUtil.h>

al::CameraTicket* rs::initWarpCheckpointCamera(const al::IUseCamera* user, const al::LiveActor* checkpoint, const al::ActorInitInfo& actorInitInfo, const char* name, sead::Vector3f*, sead::Vector3f*, sead::Vector3f*)

#include <Util/CameraUtil.h>

bool rs::requestSetCameraAngleV(const al::LiveActor* actor, f32 requestAngleV, s32 poseUpdaterIdx)

#include <Util/CameraUtil.h>

bool rs::requestResetCameraPosition(const al::LiveActor* actor, s32 poseUpdaterIdx)

#include <Util/CameraUtil.h>

bool rs::requestResetCameraAngleV(const al::LiveActor* actor, s32 poseUpdaterIdx)

#include <Util/CameraUtil.h>

bool rs::requestDownToDefaultCameraAngleBySpeed(const al::LiveActor* actor, f32 requestAngleSpeed, s32 poseUpdaterIdx)

#include <Util/CameraUtil.h>

bool rs::requestUpToTargetCameraAngleBySpeed(const al::LiveActor* actor, f32 targetAngleV, f32 requestAngleSpeed, s32 poseUpdaterIdx)

#include <Util/CameraUtil.h>

bool rs::requestMoveDownCameraAngleV(const al::LiveActor* actor, s32 poseUpdaterIdx)

#include <Util/CameraUtil.h>

bool rs::requestRiseCameraAngleByPlayerCollideJumpCode(const al::LiveActor* actor)

#include <Util/CameraUtil.h>

bool rs::requestCameraTurnToFront(const al::LiveActor* actor, f32, f32, s32 poseUpdaterIdx)

#include <Util/CameraUtil.h>

bool rs::requestCameraTurnToFront(const al::LiveActor* actor, const sead::Vector3f& trans, f32, f32, s32 poseUpdaterIdx)

#include <Util/CameraUtil.h>

void rs::setEquipmentCameraDistanceCurve(al::LiveActor* actor, const al::CameraDistanceCurve* curve)

#include <Util/CameraUtil.h>

void rs::resetEquipmentCameraDistanceCurve(al::LiveActor* actor)

#include <Util/CameraUtil.h>

void rs::setBossCameraDistanceCurve(al::LiveActor* actor, const al::CameraDistanceCurve* curve)

#include <Util/CameraUtil.h>

void rs::resetBossCameraDistanceCurve(al::LiveActor* actor)

#include <Util/CameraUtil.h>

void rs::setKoopaShellCameraDistanceCurve(al::LiveActor* actor)

#include <Util/CameraUtil.h>

void rs::resetKoopaShellCameraDistanceCurve(al::LiveActor* actor)

#include <Util/CameraUtil.h>

void rs::setTRexPatrolCameraDistanceCurve(al::LiveActor* actor)

#include <Util/CameraUtil.h>

void rs::resetTRexPatrolCameraDistanceCurve(al::LiveActor* actor)

#include <Util/CameraUtil.h>

void rs::buyItemInShopItemList(const al::IUseSceneObjHolder* user, s32 itemIdx)

#include <Util/ClothUtil.h>

bool rs::isBuyItemInShopItemList(const al::IUseSceneObjHolder* user, s32 itemIdx)

#include <Util/ClothUtil.h>

void rs::buyItem(const al::IUseSceneObjHolder* user, const ShopItem::ItemInfo* itemInfo)

#include <Util/ClothUtil.h>

void rs::buyItemAll(const al::IUseSceneObjHolder* user)

#include <Util/ClothUtil.h>

bool rs::isBuyItem(GameDataHolderAccessor accessor, const ShopItem::ItemInfo* itemInfo)

#include <Util/ClothUtil.h>

bool rs::isHaveCloth(GameDataHolderAccessor accessor, const char* name)

#include <Util/ClothUtil.h>

bool rs::isHaveCap(GameDataHolderAccessor accessor, const char* name)

#include <Util/ClothUtil.h>

bool rs::isHaveSticker(GameDataHolderAccessor accessor, const char* name)

#include <Util/ClothUtil.h>

bool rs::isHaveGift(GameDataHolderAccessor accessor, const char* name)

#include <Util/ClothUtil.h>

const sead::PtrArray<ShopItem::ItemInfo>& rs::getClothList(GameDataHolderAccessor accessor)

#include <Util/ClothUtil.h>

s32 rs::getClothListSize(GameDataHolderAccessor accessor)

#include <Util/ClothUtil.h>

bool rs::isHaveCloth(GameDataHolderAccessor accessor, s32 clothIdx)

#include <Util/ClothUtil.h>

bool rs::isHaveClothByFileId(GameDataHolderAccessor accessor, const char* clothName, s32 fileId)

#include <Util/ClothUtil.h>

s32 rs::calcHaveClothNum(GameDataHolderAccessor accessor)

#include <Util/ClothUtil.h>

void rs::buyCloth(const al::IUseSceneObjHolder* user, const char* clothName)

#include <Util/ClothUtil.h>

const sead::PtrArray<ShopItem::ItemInfo>& rs::getCapList(GameDataHolderAccessor accessor)

#include <Util/ClothUtil.h>

s32 rs::getCapListSize(GameDataHolderAccessor accessor)

#include <Util/ClothUtil.h>

bool rs::isHaveCap(GameDataHolderAccessor accessor, s32 capIdx)

#include <Util/ClothUtil.h>

bool rs::isHaveCapByFileId(GameDataHolderAccessor accessor, const char* capName, s32 fileId)

#include <Util/ClothUtil.h>

bool rs::isCompleteClothCap(const al::IUseSceneObjHolder* user)

#include <Util/ClothUtil.h>

bool rs::isCompleteCloth(const al::IUseSceneObjHolder* user)

#include <Util/ClothUtil.h>

bool rs::isCompleteCap(const al::IUseSceneObjHolder* user)

#include <Util/ClothUtil.h>

bool rs::isCompleteCloth(const al::IUseSceneObjHolder* user, s32 fileId)

#include <Util/ClothUtil.h>

bool rs::isCompleteCap(const al::IUseSceneObjHolder* user, s32 fileId)

#include <Util/ClothUtil.h>

s32 rs::calcHaveCapNum(GameDataHolderAccessor accessor)

#include <Util/ClothUtil.h>

void rs::buyCap(const al::IUseSceneObjHolder* user, const char* capName)

#include <Util/ClothUtil.h>

const sead::PtrArray<ShopItem::ItemInfo>& rs::getGiftList(GameDataHolderAccessor accessor)

#include <Util/ClothUtil.h>

s32 rs::getGiftListSize(GameDataHolderAccessor accessor)

#include <Util/ClothUtil.h>

bool rs::isHaveGift(GameDataHolderAccessor accessor, s32 giftIdx)

#include <Util/ClothUtil.h>

s32 rs::calcHaveGiftNum(GameDataHolderAccessor accessor)

#include <Util/ClothUtil.h>

bool rs::checkCompleteGift(GameDataHolderAccessor accessor, s32 fileId)

#include <Util/ClothUtil.h>

const sead::PtrArray<ShopItem::ItemInfo>& rs::getStickerList(GameDataHolderAccessor accessor)

#include <Util/ClothUtil.h>

s32 rs::getStickerListSize(GameDataHolderAccessor accessor)

#include <Util/ClothUtil.h>

bool rs::isHaveSticker(GameDataHolderAccessor accessor, s32 fileId)

#include <Util/ClothUtil.h>

s32 rs::calcHaveStickerNum(GameDataHolderAccessor accessor)

#include <Util/ClothUtil.h>

bool rs::checkCompleteSticker(GameDataHolderAccessor accessor, s32 fileId)

#include <Util/ClothUtil.h>

const char* rs::getTestClothesName()

#include <Util/ClothUtil.h>

const char* rs::getTestCapName()

#include <Util/ClothUtil.h>

const char* rs::getTestGiftName()

#include <Util/ClothUtil.h>

const char* rs::getTestStickerName()

#include <Util/ClothUtil.h>

const char* rs::getTestItemName()

#include <Util/ClothUtil.h>

const char* rs::getTestShineName()

#include <Util/ClothUtil.h>

const char* rs::getMsTextName(const ShopItem::ItemType& itemType)

#include <Util/ClothUtil.h>

const char16* rs::getDisplayName(const al::IUseMessageSystem* user, const ShopItem::ItemInfo& itemInfo)

#include <Util/ClothUtil.h>

bool rs::isTypeWear(const ShopItem::ShopItemInfo* itemInfo)

#include <Util/ClothUtil.h>

al::LiveActor* rs::createDemoPeachWedding(const al::ActorInitInfo&)

#include <Util/DemoUtil.h>

al::LiveActor* rs::createDemoCapManHeroine(const al::ActorInitInfo&)

#include <Util/DemoUtil.h>

bool rs::isRandomActionDemoChangeWorld(const al::LiveActor*, const char*)

#include <Util/DemoUtil.h>

bool rs::tryGetDemoChangeWorldRandomActionName(sead::BufferedSafeString*, s32*, const al::LiveActor*, const char*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoNormal(al::LiveActor*, bool)

#include <Util/DemoUtil.h>

void rs::addDemoActor(al::LiveActor*, bool)

#include <Util/DemoUtil.h>

void rs::requestEndDemoNormal(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoNormal(const al::Scene*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoNormal(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoNormalWithCinemaFrame(al::LiveActor*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoNormalWithCinemaFrame(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoWithPlayer(al::LiveActor*, bool)

#include <Util/DemoUtil.h>

void rs::requestEndDemoWithPlayer(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoWithPlayer(const al::Scene*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoWithPlayer(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoWithPlayerCinemaFrame(al::LiveActor*, bool)

#include <Util/DemoUtil.h>

void rs::requestEndDemoWithPlayerCinemaFrame(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoWithPlayerKeepCarry(al::LiveActor*, bool)

#include <Util/DemoUtil.h>

void rs::requestEndDemoWithPlayerKeepCarry(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoWithPlayerUseCoin(al::LiveActor*, bool)

#include <Util/DemoUtil.h>

void rs::requestEndDemoWithPlayerUseCoin(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoWithPlayerKeepBindTalk(al::LiveActor*, bool)

#include <Util/DemoUtil.h>

void rs::requestEndDemoWithPlayerKeepBindTalk(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoKeepHackTalk(al::LiveActor*, bool)

#include <Util/DemoUtil.h>

void rs::requestEndDemoKeepHackTalk(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoWithPlayerCinemaFrameTalk(al::LiveActor*, bool)

#include <Util/DemoUtil.h>

void rs::requestEndDemoWithPlayerCinemaFrameTalk(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoWithPlayerKeepCarryTalk(al::LiveActor*, bool)

#include <Util/DemoUtil.h>

void rs::requestEndDemoWithPlayerKeepCarryTalk(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoWithPlayerUseCoinTalk(al::LiveActor*, bool)

#include <Util/DemoUtil.h>

void rs::requestEndDemoWithPlayerUseCoinTalk(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoNormalTalk(al::LiveActor*, bool)

#include <Util/DemoUtil.h>

void rs::requestEndDemoNormalTalk(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoWarpToCheckpoint(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoBossBattleStart(al::LiveActor*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoBossBattleStart(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoBossBattleEnd(al::LiveActor*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoBossBattleEnd(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoShineGet(Shine*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoAchievementShineGet(al::Scene*)

#include <Util/DemoUtil.h>

void rs::endDemoShineGet(al::Scene*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoShineGet(const al::Scene*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoShineGet(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoShineDotGet(Shine*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoShineDotGet(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoShineMainGet(Shine*)

#include <Util/DemoUtil.h>

void rs::setDemoInfoDemoName(const al::LiveActor*, const char*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoShineMainGet(const al::LiveActor*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoShineMainGet(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoShineGrandGet(Shine*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoShineGrandGet(const al::LiveActor*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoShineGrandGet(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoShineAppear(al::LiveActor*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoShineAppear(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoShineAppear(const al::Scene*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoShineAppear(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoWarp(al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoWarp(const al::Scene*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoWarp(const al::LiveActor*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoWarp(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoHackStart(al::LiveActor*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoHackStart(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoAppearByBazookaElectric(al::LiveActor*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoAppearByBazookaElectric(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoLaunchBazookaElectric(al::LiveActor*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoLaunchBazookaElectric(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoSceneStartPlayerWalk(al::LiveActor*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoSceneStartPlayerWalk(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoGetLifeMaxUpItem(al::LiveActor*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoGetLifeMaxUpItem(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoBirdCarryMeat(al::LiveActor*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoBirdCarryMeat(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoBirdFindMeat(al::LiveActor*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoBirdFindMeat(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoGetTimeBalloon(al::LiveActor*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoGetTimeBalloon(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoJango(al::LiveActor*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoJango(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoTitleLogo(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoGoToEnding(al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemo(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemo(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoNormal(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoNormalWithCinemaFrame(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoWithPlayer(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoWithPlayer(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoWithPlayerCinemaFrame(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoWithPlayerCinemaFrame(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoWithPlayerKeepCarry(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoWithPlayerKeepCarry(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoWithPlayerUseCoin(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoWithPlayerUseCoin(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoWithPlayerKeepBindTalk(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoWithPlayerKeepBindTalk(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoWarpToCheckpoint(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoShineGet(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoShineGet(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoShineDotGet(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoShineDotGet(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoShineGrandGet(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoShineGrandGet(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoShineMainGet(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoShineMainGet(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoWarp(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoWarp(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoHackStart(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoHackStart(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoHackStartFirst(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isEqualDemoInfoDemoName(const al::Scene*, const char*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoScenarioCamera(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoGetLifeMaxUpItem(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoSceneStartPlayerWalk(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoBirdCarryMeat(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoBirdFindMeat(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoJango(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoJango(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoTitleLogo(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoGoToEnding(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoTalk(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoCinemaFrameTalk(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoKeepCarryTalk(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoUseCoinTalk(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoKeepHackTalk(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoNormalTalk(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoLaunchBazookaElectric(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoGiantWanderBossBattleStart(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoGiantWanderBossBattleStart(const OceanWaveActor*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoPlayerPuppetable(const al::LiveActor*)

#include <Util/DemoUtil.h>

void rs::addDemoSubActor(al::LiveActor*)

#include <Util/DemoUtil.h>

void rs::registerShineTowerRocketToDemoDirector(ShineTowerRocket*)

#include <Util/DemoUtil.h>

ShineTowerRocket* rs::tryGetShineTowerRocketFromDemoDirector(al::LiveActor*)

#include <Util/DemoUtil.h>

void rs::addDemoAppearFromHomeToList(ShineTowerRocket*)

#include <Util/DemoUtil.h>

void rs::addDemoReturnToHomeToList(ShineTowerRocket*)

#include <Util/DemoUtil.h>

void rs::addDemoRiseMapPartsToList(RiseMapPartsHolder*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoWorldIntroCamera(const al::Scene*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoWorldIntroCamera(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoScenarioCamera(const al::Scene*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoScenarioCamera(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoAppearFromHome(const al::Scene*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoAppearFromHome(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoReturnToHome(const al::Scene*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoReturnToHome(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoRiseMapParts(const al::Scene*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoRiseMapParts(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::requestStartDemoPeachCastleCap(al::LiveActor*)

#include <Util/DemoUtil.h>

void rs::requestEndDemoPeachCastleCap(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::isExistDemoAppearFromHomeInList(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isExistDemoReturnToHome(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isExistDemoRiseMapPartsInList(const al::Scene*)

#include <Util/DemoUtil.h>

al::LiveActor* rs::getRequestActor(const al::Scene*)

#include <Util/DemoUtil.h>

void rs::requestValidateDemoSkip(IUseDemoSkip*, const al::LiveActor*)

#include <Util/DemoUtil.h>

IUseDemoSkip* rs::getDemoSkipRequester(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isDemoEnableSkip(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isFirstDemo(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isEnableSkipDemo(const al::Scene*)

#include <Util/DemoUtil.h>

void rs::skipDemo(const al::Scene*)

#include <Util/DemoUtil.h>

void rs::updateOnlyDemoGraphics(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isFirstDemoWorldIntroCamera(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isFirstDemoScenarioStartCamera(const al::LiveActor*)

#include <Util/DemoUtil.h>

void rs::noticeDemoSkipStart(const al::Scene*)

#include <Util/DemoUtil.h>

void rs::noticeDemoSkipEnd(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isWaitDemoSkipEnd(const al::LiveActor*)

#include <Util/DemoUtil.h>

CaptionInfoHolder* rs::createCaptionInfoHolder(const char*)

#include <Util/DemoUtil.h>

void rs::validateDemoCaption(const al::LiveActor*, CaptionInfoHolder*)

#include <Util/DemoUtil.h>

bool rs::isActiveDemoWithCinemaCaption(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::tryAppearCinemaCaption(const al::Scene*, CinemaCaption*)

#include <Util/DemoUtil.h>

void rs::startCloseDemoFade(const al::LiveActor*, s32)

#include <Util/DemoUtil.h>

void rs::startOpenDemoFade(const al::LiveActor*, s32)

#include <Util/DemoUtil.h>

bool rs::isDemoFadeCloseEnd(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::isDemoFadeOpenEnd(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::isDemoFadeWipeStateEnableOpenMenuOrSnapShotMode(const al::Scene*)

#include <Util/DemoUtil.h>

DemoHackFirstDirector* rs::tryCreateDemoHackFirstDirector(al::LiveActor*, s32, const al::ActorInitInfo&)

#include <Util/DemoUtil.h>

void rs::noticeDemoStartToDemoHackFirstDirector(const al::Scene*)

#include <Util/DemoUtil.h>

void rs::setBossBarrierField(BarrierField*)

#include <Util/DemoUtil.h>

BarrierField* rs::tryGetBossBarrierField(const al::LiveActor*)

#include <Util/DemoUtil.h>

void rs::setDemoEnvironmentChangeFlag(const al::Scene*, bool)

#include <Util/DemoUtil.h>

void rs::setDemoEnvironmentChangeFlag(const al::LiveActor*, bool)

#include <Util/DemoUtil.h>

bool rs::isDemoEnvironmentChange(const al::Scene*)

#include <Util/DemoUtil.h>

bool rs::isDemoEnvironmentChange(const al::LiveActor*)

#include <Util/DemoUtil.h>

s32 rs::getRandomActionIndexDemoChangeWorld(const al::LiveActor*)

#include <Util/DemoUtil.h>

void rs::setDemoInfoDemoName(const al::Scene*, const char*)

#include <Util/DemoUtil.h>

void rs::getDemoInfoDemoName(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::isTriggerDemoCancel(const al::IUseSceneObjHolder*)

#include <Util/DemoUtil.h>

void rs::updateDemoSystemOnly(const al::Scene*)

#include <Util/DemoUtil.h>

void rs::notifyDisableUpdateCamera(const al::LiveActor*)

#include <Util/DemoUtil.h>

bool rs::isDisableUpdateCamera(const al::Scene*)

#include <Util/DemoUtil.h>

CapTargetInfo* rs::createCapTargetInfo(al::LiveActor*, const char*)

#include <Util/Hack.h>

CapTargetInfo* rs::createCapTargetInfoWithPlayerCollider(al::LiveActor*, IUsePlayerCollision*, const char*)

#include <Util/Hack.h>

CapTargetInfo* rs::createCapTargetInfoHackMapParts(al::LiveActor*)

#include <Util/Hack.h>

CapTargetInfo* rs::createCapTargetInfoLockOnOnlyNoArchive(al::LiveActor*, const sead::Matrix34f*)

#include <Util/Hack.h>

void rs::requestLockOnCapHitReaction(const al::LiveActor*, const CapTargetInfo*, const char*)

#include <Util/Hack.h>

IUsePlayerHack* rs::startHack(al::HitSensor*, al::HitSensor*, al::LiveActor*)

#include <Util/Hack.h>

void rs::endHack(IUsePlayerHack**)

#include <Util/Hack.h>

void rs::endHackDir(IUsePlayerHack**, const sead::Vector3f&)

#include <Util/Hack.h>

void rs::endHackTargetQuat(IUsePlayerHack**, const sead::Quatf&, const sead::Vector3f&)

#include <Util/Hack.h>

void rs::endHackFromTargetPos(IUsePlayerHack**, const sead::Vector3f&)

#include <Util/Hack.h>

void rs::endHackFromTargetPos(IUsePlayerHack**, const sead::Vector3f&, const sead::Vector3f&)

#include <Util/Hack.h>

void rs::endHackFromTargetPos(IUsePlayerHack**, const sead::Vector3f&, const sead::Quatf&, const sead::Vector3f&)

#include <Util/Hack.h>

void rs::endHackWithDamage(IUsePlayerHack**)

#include <Util/Hack.h>

void rs::endHackWithDamageAndVelocity(IUsePlayerHack**, const sead::Vector3f&)

#include <Util/Hack.h>

void rs::endHackEscapeScale(IUsePlayerHack**, f32)

#include <Util/Hack.h>

void rs::endHackDirEscapeScale(IUsePlayerHack**, const sead::Vector3f&, f32)

#include <Util/Hack.h>

void rs::endHackDirEscapeScalePose(IUsePlayerHack**, const sead::Quatf&, const sead::Vector3f&, f32)

#include <Util/Hack.h>

void rs::endHackAirVelocity(IUsePlayerHack**, const sead::Vector3f&, const sead::Quatf&, const sead::Vector3f&, s32)

#include <Util/Hack.h>

void rs::endHackElectricWireToDestination(IUsePlayerHack**, const sead::Vector3f&, const sead::Vector3f&)

#include <Util/Hack.h>

void rs::endHackFastenerToDestination(IUsePlayerHack**, const sead::Vector3f&, const sead::Vector3f&)

#include <Util/Hack.h>

void rs::endHackBazookaElectricToDestination(IUsePlayerHack**, const sead::Vector3f&, const sead::Vector3f&, const sead::Quatf&, s32, f32)

#include <Util/Hack.h>

void rs::endHackThrowed(IUsePlayerHack**, const sead::Vector3f&)

#include <Util/Hack.h>

bool rs::requestDamage(IUsePlayerHack*)

#include <Util/Hack.h>

void rs::syncDamageVisibility(al::LiveActor*, const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isDamageVisibilityHide(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isTouchHackCancelCollisionCode(const al::LiveActor*, const IUsePlayerCollision*)

#include <Util/Hack.h>

bool rs::isTouchHackDamageCollisionCode(const al::LiveActor*, const IUsePlayerCollision*)

#include <Util/Hack.h>

void rs::updateMaterialCode(al::LiveActor*, const IUsePlayerCollision*)

#include <Util/Hack.h>

IUsePlayerHack* rs::startHackStartDemo(IUsePlayerHack*, al::LiveActor*)

#include <Util/Hack.h>

IUsePlayerHack* rs::startHackStartDemoPuppetable(IUsePlayerHack*, al::LiveActor*)

#include <Util/Hack.h>

void rs::addHackStartDemoActor(IUsePlayerHack*, al::LiveActor*)

#include <Util/Hack.h>

void rs::endHackStartDemo(IUsePlayerHack*, al::LiveActor*)

#include <Util/Hack.h>

bool rs::tryEndHackStartDemo(IUsePlayerHack*, al::LiveActor*)

#include <Util/Hack.h>

bool rs::isActiveHackStartDemo(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isHackStartDemoEnterMario(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isHackerStopMove(const al::LiveActor*, const IUsePlayerHack*, f32)

#include <Util/Hack.h>

bool rs::isHackerStopMoveGround(const al::LiveActor*, const IUsePlayerHack*, f32, const IUsePlayerCollision*)

#include <Util/Hack.h>

bool rs::sendMsgHackerNoReaction(const IUsePlayerHack*, al::HitSensor*, al::HitSensor*)

#include <Util/Hack.h>

bool rs::sendMsgHackerNoReactionWithoutShine(const IUsePlayerHack*, al::HitSensor*, al::HitSensor*)

#include <Util/Hack.h>

bool rs::isMsgHackerDamageAndCancel(const al::SensorMsg*)

#include <Util/Hack.h>

bool rs::isMsgEnableMapCheckPointWarpCollidedGround(const al::SensorMsg*, const al::LiveActor*)

#include <Util/Hack.h>

bool rs::isMsgEnableMapCheckPointWarpCollidedGround(const al::SensorMsg*, const IUsePlayerCollision*)

#include <Util/Hack.h>

bool rs::receiveMsgRequestTransferHack(const al::SensorMsg*, IUsePlayerHack*, al::HitSensor*)

#include <Util/Hack.h>

void rs::hideHackCap(IUsePlayerHack*)

#include <Util/Hack.h>

void rs::showHackCap(IUsePlayerHack*)

#include <Util/Hack.h>

void rs::hideShadowHackCap(IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isHackCapSeparateFlying(IUsePlayerHack*)

#include <Util/Hack.h>

void rs::calcGroundHeightHackerDepthShadowMapLength(al::LiveActor*, const IUsePlayerHack*, const sead::Vector3f&, f32, f32)

#include <Util/Hack.h>

void rs::cutGroundHeightHackerDepthShadowMapLength(al::LiveActor*, const IUsePlayerHack*, const char*, const sead::Vector3f&, f32, f32)

#include <Util/Hack.h>

void rs::checkExistHeightSpaceAboveGround(f32*, const IUsePlayerHack*, f32)

#include <Util/Hack.h>

void rs::requestRecoverySafetyPoint(IUsePlayerHack*, const sead::Vector3f&, const sead::Vector3f&)

#include <Util/Hack.h>

bool rs::trySnapTransToSnapMoveArea(al::LiveActor*, bool, const sead::Vector3f&, f32)

#include <Util/Hack.h>

void rs::updateHackActorVisibilityBySeparatePlay(al::LiveActor*, IUsePlayerHack*, const char*, const char*)

#include <Util/Hack.h>

void rs::startReset(al::LiveActor*)

#include <Util/Hack.h>

void rs::endReset(al::LiveActor*)

#include <Util/Hack.h>

void rs::calcHackerMoveVec(sead::Vector3f*, const IUsePlayerHack*, const sead::Vector3f&)

#include <Util/Hack.h>

bool rs::calcHackerMoveDir(sead::Vector3f*, const IUsePlayerHack*, const sead::Vector3f&)

#include <Util/Hack.h>

void rs::calcHackerWallInputVec(sead::Vector3f*, sead::Vector3f*, const IUsePlayerHack*, const sead::Vector3f&)

#include <Util/Hack.h>

void rs::calcHackerWallInputVec(sead::Vector3f*, sead::Vector3f*, const sead::Vector2f&, const sead::Vector3f&)

#include <Util/Hack.h>

f32 rs::getHackMoveStickRaw(const IUsePlayerHack*)

#include <Util/Hack.h>

void rs::calcHackerWallInputDir(sead::Vector3f*, sead::Vector3f*, const IUsePlayerHack*, const sead::Vector3f&)

#include <Util/Hack.h>

bool rs::addHackActorAccelStick(al::LiveActor*, const IUsePlayerHack*, sead::Vector3f*, f32, const sead::Vector3f&)

#include <Util/Hack.h>

void rs::calcHackMovePower(const IUsePlayerHack*)

#include <Util/Hack.h>

void rs::checkHackerMoveDir(const IUsePlayerHack*, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <Util/Hack.h>

void rs::calcHackerTrampleJumpParam(f32*, f32*, s32*, al::LiveActor*, const IUsePlayerHack*, f32, f32, f32, f32, f32, s32, f32, f32, f32, f32, f32)

#include <Util/Hack.h>

bool rs::isOnHackMoveStick(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isHoldHackJump(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isOnHackMoveStickDeepDown(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isOnHackMoveStickGreater(const IUsePlayerHack*, f32)

#include <Util/Hack.h>

bool rs::isTriggerHackAction(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isTriggerHackPreInputAction(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isHoldHackAction(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isReleaseHackAction(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isTriggerHackJump(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isTriggerHackPreInputJump(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isReleaseHackJump(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isTriggerHackAnyButton(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isTriggerHackPreInputAnyButton(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isHoldHackAnyButton(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isReleaseHackAnyButton(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isTriggerHackSeparateJump(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isHoldHackSeparateJump(const IUsePlayerHack*)

#include <Util/Hack.h>

void rs::getHackStickRotateSpeed(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isTriggerHackSwing(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isTriggerHackSwingDirLeft(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isTriggerHackSwingDirRight(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isTriggerHackSwingDoubleHand(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isTriggerHackSwingDoubleHandReverseDir(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isTriggerHackSwingDoubleHandReverseInsideDir(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isTriggerHackSwingDoubleHandReverseOutsideDir(const IUsePlayerHack*)

#include <Util/Hack.h>

void rs::getHackPoseRotZDegreeLeft(const IUsePlayerHack*)

#include <Util/Hack.h>

void rs::getHackPoseRotZDegreeRight(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isTriggerTankCameraReset(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isTriggerHackSwingLeftHand(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isTriggerHackSwingRightHand(const IUsePlayerHack*)

#include <Util/Hack.h>

void rs::getHackSwingThrowDir(const IUsePlayerHack*)

#include <Util/Hack.h>

void rs::getHackSwingLeftHandDir(const IUsePlayerHack*)

#include <Util/Hack.h>

void rs::getHackSwingRightHandDir(const IUsePlayerHack*)

#include <Util/Hack.h>

void rs::getHackSwingVelLeftHand(const IUsePlayerHack*)

#include <Util/Hack.h>

void rs::getHackSwingVelRightHand(const IUsePlayerHack*)

#include <Util/Hack.h>

void rs::getHackCameraStickRaw(const IUsePlayerHack*)

#include <Util/Hack.h>

void rs::getRadiconInputSteeringValue(const IUsePlayerHack*)

#include <Util/Hack.h>

void rs::getRadiconInputThrottleValue(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isTriggerRecorderPlay(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isTriggerRecorderReverse(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isHoldRecorderPlay(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isHoldRecorderReverse(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isTriggerRecorderJump(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isTriggerRecorderCancel(const IUsePlayerHack*)

#include <Util/Hack.h>

void rs::getHackGemyLeftStickRaw()

#include <Util/Hack.h>

void rs::getHackGemyRightStickRaw()

#include <Util/Hack.h>

bool rs::isTriggerGemyResetCamera(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isTriggerGemyChangeCamera(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isTriggerSubjectiveCamera(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isTriggerFlutter(const IUsePlayerHack*, f32)

#include <Util/Hack.h>

bool rs::isTriggerFukankunZoomOn(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isTriggerFukankunZoomOff(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isHoldFukankunZoom(const IUsePlayerHack*)

#include <Util/Hack.h>

void rs::getPoleJumpPadPoseMtx(sead::Matrix33f*)

#include <Util/Hack.h>

void rs::getPoleJumpPadAcceleration(sead::Vector3f*)

#include <Util/Hack.h>

bool rs::isTriggerIceClimberClimbLeft(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isTriggerIceClimberClimbRight(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::isTriggerIceClimberFall(const IUsePlayerHack*)

#include <Util/Hack.h>

bool rs::tryCloseHackTutorial(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::changeHackTutorialText(const al::IUseSceneObjHolder*, const char*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::resetHackTutorialText(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::tryAppearBindTutorial(const al::IUseSceneObjHolder*, const BindInfo&)

#include <Util/InputInterruptTutorialUtil.h>

bool rs::tryCloseBindTutorial(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

bool rs::tryCloseObjectTutorial(const al::IUseSceneObjHolder*, const char*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::appearFirstHackTutorialFrog(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::appearFirstHackTutorialKoopa(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

bool rs::tryAppearObjectTutorial(const al::IUseSceneObjHolder*, const char*)

#include <Util/InputInterruptTutorialUtil.h>

bool rs::tryAppearObjectTutorialOpening(const al::IUseSceneObjHolder*, const char*, const char*)

#include <Util/InputInterruptTutorialUtil.h>

bool rs::tryCloseObjectTutorialOpening(const al::IUseSceneObjHolder*, const char*)

#include <Util/InputInterruptTutorialUtil.h>

bool rs::tryAppearObjectTutorialHipDrop(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

bool rs::tryCloseObjectTutorialHipDrop(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

bool rs::tryAppearObjectTutorialCapThrow(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

bool rs::tryCloseObjectTutorialCapThrow(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::tryAppearPlayerGrabPoleTutorial(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::tryClosePlayerGrabPoleTutorial(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::tryAppearPlayerClimbPoleTutorial(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::tryClosePlayerClimbPoleTutorial(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::tryAppearPlayerClimbPoleTopTutorial(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::tryClosePlayerClimbPoleTopTutorial(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::tryAppearKoopaCapTutorial(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::tryAppearKoopaCapTutorialNoMovie(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::tryCloseKoopaCapTutorial(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::changeSeparatePlayTutorial(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::changeSinglePlayTutorial(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::changeEnableCapTutorial(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::changeDisableCapTutorial(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::tryAppearSignboardTutorial(const al::IUseSceneObjHolder*, const char*)

#include <Util/InputInterruptTutorialUtil.h>

bool rs::isExistSignboardTutorialMovie(const al::IUseSceneObjHolder*, const char*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::tryCloseSignboardTutorial(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::tryAppearAmiiboHelpNpcTutorial(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::tryAppearAmiiboHelpNpcSeparateTutorial(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

bool rs::tryAppearPlayerCameraSubjectiveTutorial(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::tryClosePlayerCameraSubjectiveTutorial(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::appearCapMsgTutorial(const al::IUseSceneObjHolder*, const char*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::closeCapMsgTutorial(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::appearRaceTutorial(const al::IUseSceneObjHolder*, const char*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::killRaceTutorial(const al::IUseSceneObjHolder*, const char*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::appearRaceTutorialTutorial(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

bool rs::isShowTutorial(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

bool rs::isShowObjectTutorial(const al::IUseSceneObjHolder*, const char*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::hideTutorial(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::showTutorial(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::appearTutorialForDemo(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::killTutorial(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

void rs::updateGyroText(const al::IUseSceneObjHolder*)

#include <Util/InputInterruptTutorialUtil.h>

ItemType::ValueType rs::getItemType(const al::ActorInitInfo& info)

#include <Util/ItemUtil.h>

ItemType::ValueType rs::getItemTypeFromName(const char* name)

#include <Util/ItemUtil.cpp>

ItemType::ValueType rs::getItemType(const char* name)

#include <Util/ItemUtil.h>

bool rs::isItemTypeKuriboMini(s32* out, s32 type)

#include <Util/ItemUtil.h>

bool rs::tryInitItemAndAddToKeeper(al::LiveActor* actor, s32 itemType, const al::ActorInitInfo& info, bool isAppearAbove)

#include <Util/ItemUtil.cpp>

void rs::initItemByPlacementInfo(al::LiveActor* actor, const al::ActorInitInfo& info, bool isAppearAbove)

#include <Util/ItemUtil.h>

bool rs::tryInitItemByPlacementInfo(al::LiveActor* actor, const al::ActorInitInfo& info, bool isAppearAbove)

#include <Util/ItemUtil.h>

void rs::initItem2DByPlacementInfo(al::LiveActor* actor, const al::ActorInitInfo& info)

#include <Util/ItemUtil.h>

bool rs::tryInitItem2DByPlacementInfo(al::LiveActor* actor, const al::ActorInitInfo& info)

#include <Util/ItemUtil.h>

bool rs::tryInitItem(al::LiveActor* actor, s32 itemType, const al::ActorInitInfo& info, bool isAppearAbove)

#include <Util/ItemUtil.h>

Shine* rs::tryInitShineByPlacementInfoWithItemMenu(const al::ActorInitInfo& info)

#include <Util/ItemUtil.h>

Shine* rs::initShineByPlacementInfo(const al::ActorInitInfo& info)

#include <Util/ItemUtil.h>

Shine* rs::tryInitLinkShine(const al::ActorInitInfo& info, const char* name, s32 linkIndex)

#include <Util/ItemUtil.h>

Shine* rs::tryInitLinkShineHintPhoto(const al::ActorInitInfo& info, const char* name, s32 linkIndex)

#include <Util/ItemUtil.h>

Shine* rs::initLinkShine(const al::ActorInitInfo& info, const char* name, s32 linkIndex)

#include <Util/ItemUtil.h>

Shine* rs::initLinkShopShine(const al::ActorInitInfo& info, const char* name)

#include <Util/ItemUtil.h>

Shine* rs::initLinkShineChipShine(const al::ActorInitInfo& info)

#include <Util/ItemUtil.h>

Shine* rs::initLinkBossShine(const al::ActorInitInfo& info)

#include <Util/ItemUtil.h>

void rs::createShineEffectInsideObject(Shine* shine, const al::LiveActor* actor, const al::ActorInitInfo& info)

#include <Util/ItemUtil.h>

void rs::appearPopupShine(Shine* shine)

#include <Util/ItemUtil.h>

void rs::appearPopupShine(Shine* shine, const al::LiveActor* actor)

#include <Util/ItemUtil.h>

void rs::appearPopupShine(Shine* shine, const sead::Vector3f& trans)

#include <Util/ItemUtil.h>

void rs::appearPopupShineWithoutDemo(Shine* shine)

#include <Util/ItemUtil.h>

void rs::appearPopupShineWithoutDemo(Shine* shine, const al::LiveActor* actor)

#include <Util/ItemUtil.h>

void rs::appearPopupShineWithoutDemo(Shine* shine, const sead::Vector3f& trans)

#include <Util/ItemUtil.h>

void rs::appearPopupShineWithoutWarp(Shine* shine)

#include <Util/ItemUtil.h>

void rs::appearPopupShineGrandByBoss(Shine* shine, s32 a2)

#include <Util/ItemUtil.h>

void rs::appearWaitShine(Shine* shine)

#include <Util/ItemUtil.h>

void rs::appearWaitShine(Shine* shine, const sead::Vector3f& trans)

#include <Util/ItemUtil.h>

bool rs::isEndAppearShine(const Shine* shine)

#include <Util/ItemUtil.h>

bool rs::isGotShine(const Shine* shine)

#include <Util/ItemUtil.h>

bool rs::isAliveShine(const Shine* shine)

#include <Util/ItemUtil.h>

bool rs::isMainShine(const Shine* shine)

#include <Util/ItemUtil.h>

void rs::updateHintTrans(const Shine* shine, const sead::Vector3f& trans)

#include <Util/ItemUtil.h>

void rs::appearShineAndJoinBossDemo(Shine* shine, const char* name, const sead::Quatf& quat, const sead::Vector3f& trans)

#include <Util/ItemUtil.h>

void rs::endShineBossDemo(Shine* shine)

#include <Util/ItemUtil.h>

void rs::endShineBossDemoAndStartFall(Shine* shine, f32 a2)

#include <Util/ItemUtil.h>

void rs::setAppearItemFactorByMsg(const al::LiveActor* actor, const al::SensorMsg* msg, const al::HitSensor* sensor)

#include <Util/ItemUtil.h>

void rs::setAppearItemFactorAndOffsetByMsg(const al::LiveActor* actor, const al::SensorMsg* msg, const al::HitSensor* sensor)

#include <Util/ItemUtil.h>

void rs::setAppearItemFactorAndOffsetForCombo(const al::LiveActor* actor, const al::SensorMsg* msg, const al::HitSensor* sensor, bool isSuperCombo)

#include <Util/ItemUtil.h>

void rs::appearItemFromObj(al::LiveActor* actor, const sead::Vector3f& trans, const sead::Quatf& quat, f32 offset)

#include <Util/ItemUtil.h>

void rs::appearItemFromObj(al::LiveActor* actor, al::HitSensor* sensor, f32 offset)

#include <Util/ItemUtil.h>

void rs::appearItemFromObj(al::LiveActor* actor, al::HitSensor* sensor, const sead::Vector3f& offset)

#include <Util/ItemUtil.h>

void rs::appearItemFromObjGravity(al::LiveActor* actor, al::HitSensor* sensor, const sead::Vector3f& offset)

#include <Util/ItemUtil.h>

bool rs::tryAppearMultiCoinFromObj(al::LiveActor* actor, const sead::Vector3f& trans, s32 step, f32 offsetAbove)

#include <Util/ItemUtil.h>

bool rs::tryAppearMultiCoinFromObj(al::LiveActor* actor, const sead::Vector3f& trans, const sead::Quatf& quat, s32 step, f32 offsetAbove)

#include <Util/ItemUtil.h>

bool rs::tryAppearMultiCoinFromObj(al::LiveActor* actor, al::HitSensor* sensor, s32 step, f32 offsetAbove)

#include <Util/ItemUtil.h>

bool rs::tryAppearMultiCoinFromObj(al::LiveActor* actor, al::HitSensor* sensor, s32 step, const sead::Vector3f& offset)

#include <Util/ItemUtil.h>

void rs::syncCoin2DAnimFrame(al::LiveActor* actor, const char* name)

#include <Util/ItemUtil.h>

const char* rs::getStageCoinCollectArchiveName(const al::LiveActor* actor)

#include <Util/ItemUtil.h>

const char* rs::getStageCoinCollectEmptyArchiveName(const al::LiveActor* actor)

#include <Util/ItemUtil.h>

const char* rs::getStageCoinCollect2DArchiveName(const al::LiveActor* actor)

#include <Util/ItemUtil.h>

const char* rs::getStageCoinCollect2DEmptyArchiveName(const al::LiveActor* actor)

#include <Util/ItemUtil.h>

s32 rs::getStageShineAnimFrame(const al::LiveActor* actor)

#include <Util/ItemUtil.h>

s32 rs::getStageShineAnimFrame(const al::LiveActor* actor, s32 worldId)

#include <Util/ItemUtil.h>

s32 rs::getStageShineAnimFrame(const al::LiveActor* actor, const char* stageName)

#include <Util/ItemUtil.h>

void rs::startShineAnimAndSetFrameAndStop(al::LiveActor* actor, const char* animName, s32 frame, bool isMatAnim)

#include <Util/ItemUtil.cpp>

void rs::setStageShineAnimFrame(al::LiveActor* actor, const char* stageName, s32 shineAnimFrame, bool isMatAnim)

#include <Util/ItemUtil.h>

const char* rs::getStageShineArchiveName(const al::LiveActor* actor, const char* stageName)

#include <Util/ItemUtil.h>

const char* rs::getStageShineEmptyArchiveName(const al::LiveActor* actor, const char* stageName)

#include <Util/ItemUtil.h>

void rs::setMaterialAsEmptyModel(al::LiveActor* actor)

#include <Util/ItemUtil.h>

void rs::setProjectionMtxAsEmptyModel2d(al::LiveActor* actor, const sead::Vector2f& vec)

#include <Util/ItemUtil.h>

rs::SEAD_ENUM(ItemType, None = -1, Coin, Coin2D, CoinBlow, CoinBlowVeryLittle, CoinPopUp, CoinPopUpWithoutHitReaction, Coin3, Coin5, Coin10, Coin10Auto, Coin5Count, Coin100, LifeUpItem, LifeUpItemBack, LifeUpItem2D, LifeMaxUpItem, LifeMaxUpItem2D, Shine, AirBubble, DotMarioCat, KuriboMini3, KuriboMini8, CoinStackBound, Random)

#include <Util/ItemUtil.h>

void rs::appearRandomItemFromObj(al::LiveActor* actor, al::HitSensor* sensor, f32 offset)

#include <Util/ItemUtil.h>

void rs::addDemoRacePrizeCoin(al::LiveActor* actor)

#include <Util/ItemUtil.h>

void rs::resetJudge(IJudge* judge)

#include <Util/JudgeUtil.h>

void rs::updateJudge(IJudge* judge)

#include <Util/JudgeUtil.h>

bool rs::isJudge(const IJudge* judge)

#include <Util/JudgeUtil.h>

bool rs::updateJudgeAndResult(IJudge* judge)

#include <Util/JudgeUtil.h>

bool rs::judgeAndResetReturnTrue(IJudge* judge)

#include <Util/JudgeUtil.h>

bool rs::isEnableShowDemoAfterOpenMoonRockFirst(const al::LiveActor* actor)

#include <Util/MoonRockUtil.h>

bool rs::isFirstDemoOpenMoonRock(const al::LiveActor* actor)

#include <Util/MoonRockUtil.h>

bool rs::isEnableShowDemoMoonRockMapWorld(const al::LiveActor* actor)

#include <Util/MoonRockUtil.h>

void rs::showDemoAfterOpenMoonRockFirst(const al::LiveActor* actor)

#include <Util/MoonRockUtil.h>

void rs::showDemoMoonRockMapWorld(const al::LiveActor* actor)

#include <Util/MoonRockUtil.h>

const char* rs::getNetworkPrototypeDirectory()

#include <Util/NetworkUtil.h>

void rs::convertComputerNameToFullName(sead::BufferedSafeString* fullName, const char* computerName)

#include <Util/NetworkUtil.h>

void rs::convertComputerNameToSecondName(sead::BufferedSafeString* secondName, const char* computerName)

#include <Util/NetworkUtil.h>

void rs::convertComputerNameToSecondKanaName(sead::BufferedSafeString* secondKanaName, const char* computerName)

#include <Util/NetworkUtil.h>

bool rs::tryApplyNpcMaterialAnimPresetFromPlacementInfo(al::LiveActor*, const al::ActorInitInfo&, const TalkNpcParam*)

#include <Util/NpcAnimUtil.h>

void rs::setNpcMaterialAnimFromPlacementInfo(al::LiveActor*, const al::ActorInitInfo&)

#include <Util/NpcAnimUtil.h>

bool rs::tryUpdateNpcEyeLineAnim(al::LiveActor*, const TalkNpcParam*)

#include <Util/NpcAnimUtil.h>

bool rs::tryUpdateNpcEyeLineAnimToTarget(al::LiveActor*, const TalkNpcParam*, const sead::Vector3f&, bool)

#include <Util/NpcAnimUtil.h>

void rs::resetNpcEyeLineAnim(al::LiveActor*)

#include <Util/NpcAnimUtil.h>

bool rs::tryUpdateNpcFacialAnim(al::LiveActor*, const TalkNpcParam*)

#include <Util/NpcAnimUtil.h>

void rs::trySwitchDepthToSelfShadow(al::LiveActor*)

#include <Util/NpcAnimUtil.h>

bool rs::tryReceiveMsgPlayerDisregard(const al::SensorMsg*, al::HitSensor*, const TalkNpcParam*)

#include <Util/NpcAnimUtil.h>

void rs::attackSensorNpcCommon(al::HitSensor*, al::HitSensor*)

#include <Util/NpcAnimUtil.h>

bool rs::receiveMsgNpcCommonNoReaction(const al::SensorMsg*, al::HitSensor*, al::HitSensor*)

#include <Util/NpcAnimUtil.h>

void rs::calcNpcPushVecBetweenSensors(sead::Vector3f*, al::HitSensor*, al::HitSensor*)

#include <Util/NpcAnimUtil.h>

NpcJointLookAtController* rs::createAndAppendNpcJointLookAtController(al::LiveActor*, const TalkNpcParam*)

#include <Util/NpcAnimUtil.h>

NpcJointLookAtController* rs::tryCreateAndAppendNpcJointLookAtController(al::LiveActor*, const TalkNpcParam*)

#include <Util/NpcAnimUtil.h>

NpcJointLookAtController* rs::tryCreateAndAppendNpcJointLookAtController(al::LiveActor*, const TalkNpcParam*, f32)

#include <Util/NpcAnimUtil.h>

void rs::setPlayerEyeSensorHitHolder(NpcJointLookAtController*, const PlayerEyeSensorHitHolder*)

#include <Util/NpcAnimUtil.h>

s32 rs::getNpcJointLookAtControlJointNum(const TalkNpcParam*)

#include <Util/NpcAnimUtil.h>

void rs::updateNpcJointLookAtController(NpcJointLookAtController*)

#include <Util/NpcAnimUtil.h>

void rs::cancelUpdateNpcJointLookAtController(NpcJointLookAtController*)

#include <Util/NpcAnimUtil.h>

void rs::updateNpcJointLookAtControllerLookAtDistance(NpcJointLookAtController*, f32)

#include <Util/NpcAnimUtil.h>

void rs::invalidateNpcJointLookAtController(NpcJointLookAtController*)

#include <Util/NpcAnimUtil.h>

void rs::validateNpcJointLookAtController(NpcJointLookAtController*)

#include <Util/NpcAnimUtil.h>

void rs::requestLookAtTargetTrans(NpcJointLookAtController*, const sead::Vector3f&)

#include <Util/NpcAnimUtil.h>

void rs::initCapWorldNpcTail(al::LiveActor*)

#include <Util/NpcAnimUtil.h>

bool rs::tryStartForestManFlowerAnim(al::LiveActor*)

#include <Util/NpcAnimUtil.h>

bool rs::tryUpdateMaterialCodeByFloorCollisionOnArrow(al::LiveActor*)

#include <Util/NpcAnimUtil.h>

void rs::tryAttachConnectorToCollisionTFSV(al::LiveActor*, al::MtxConnector*, sead::Quatf*)

#include <Util/NpcAnimUtil.h>

void rs::tryConnectToCollisionTFSV(al::LiveActor*, const al::MtxConnector*, sead::Quatf*)

#include <Util/NpcAnimUtil.h>

al::LiveActor* rs::tryGetSubActorCityMayorFace(const al::LiveActor*)

#include <Util/NpcAnimUtil.h>

void rs::syncActionCityMayorFace(al::LiveActor*)

#include <Util/NpcAnimUtil.h>

void rs::syncMtsAnimCityMayorFace(al::LiveActor*)

#include <Util/NpcAnimUtil.h>

bool rs::isExistFaceAnim(al::LiveActor*, const char*)

#include <Util/NpcAnimUtil.h>

void rs::animateCityMayorFace(al::LiveActor*, const char*, f32)

#include <Util/NpcAnimUtil.h>

ShellActorStateReaction* rs::createNpcStateReaction(al::LiveActor*, const TalkNpcParam*, const NpcStateReactionParam*)

#include <Util/NpcAnimUtil.h>

bool rs::isInvalidTrampleSensor(const al::HitSensor*, const TalkNpcParam*)

#include <Util/NpcAnimUtil.h>

al::EventFlowExecutor* rs::initEventFlow(al::LiveActor*, const al::ActorInitInfo&, const char*, const char*)

#include <Util/NpcEventFlowUtil.h>

void rs::startEventFlow(al::EventFlowExecutor*, const char*)

#include <Util/NpcEventFlowUtil.h>

bool rs::updateEventFlow(al::EventFlowExecutor*)

#include <Util/NpcEventFlowUtil.h>

void rs::initEventMessageTagDataHolder(al::EventFlowExecutor*, const al::MessageTagDataHolder*)

#include <Util/NpcEventFlowUtil.h>

bool rs::trySendMsgPlayerReflectOrTrample(const al::LiveActor*, al::HitSensor*, al::HitSensor*)

#include <Util/ObjUtil.h>

bool rs::findWallCatchPos(const al::CollisionParts**, sead::Vector3f*, sead::Vector3f*, const al::LiveActor*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32, f32, f32, f32, f32, f32, f32)

#include <Util/ObjUtil.h>

bool rs::findGrabCeilPosNoWallHit(const al::CollisionParts**, sead::Vector3f*, sead::Vector3f*, sead::Vector3f*, const al::LiveActor*, const sead::Vector3f&, const sead::Vector3f&, f32, f32, f32)

#include <Util/ObjUtil.h>

bool rs::findGrabCeilPosWallHit(const al::CollisionParts**, sead::Vector3f*, sead::Vector3f*, sead::Vector3f*, const al::LiveActor*, const sead::Vector3f&, const sead::Vector3f&, f32, f32, f32)

#include <Util/ObjUtil.h>

void rs::calcOffsetAllRoot(sead::Vector3f* offset, const PlayerModelHolder* model)

#include <Util/ObjUtil.h>

bool rs::convergeOnGroundCount(s32*, const al::LiveActor*, const IUsePlayerCollision*, s32, s32)

#include <Util/ObjUtil.h>

bool rs::isOnGroundRunAngle(const al::LiveActor*, const IUsePlayerCollision*, const PlayerConst*)

#include <Util/ObjUtil.h>

void rs::startHitReactionHipDropLand(al::LiveActor*, bool)

#include <Util/ObjUtil.h>

void rs::waitGround(al::LiveActor*, const IUsePlayerCollision*, f32, f32, f32, f32)

#include <Util/ObjUtil.h>

void rs::slerpUpFront(al::LiveActor*, const sead::Vector3f&, const sead::Vector3f&, f32, f32)

#include <Util/ObjUtil.h>

bool rs::calcSlideDir(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&)

#include <Util/ObjUtil.h>

void rs::moveDivingJump(al::LiveActor*, const sead::Vector3f&, f32, f32, f32, f32, f32, f32, f32, f32)

#include <Util/ObjUtil.h>

void rs::sendPlayerCollisionTouchMsg(const al::LiveActor*, al::HitSensor*, const IUsePlayerCollision*)

#include <Util/ObjUtil.h>

f32 rs::getGroundHeight(const IUsePlayerHeightCheck*)

#include <Util/PlayerCollisionUtil.h>

const sead::Vector3f& rs::getCollidedWallPos(const IUsePlayerCollision*)

#include <Util/PlayerCollisionUtil.h>

const sead::Vector3f& rs::getCollidedWallNormal(const IUsePlayerCollision*)

#include <Util/PlayerCollisionUtil.h>

const al::CollisionParts* rs::getCollidedWallCollisionParts(const IUsePlayerCollision*)

#include <Util/PlayerCollisionUtil.h>

const sead::Vector3f& rs::getCollidedGroundPos(const IUsePlayerCollision*)

#include <Util/PlayerCollisionUtil.h>

const sead::Vector3f& rs::getCollidedGroundNormal(const IUsePlayerCollision*)

#include <Util/PlayerCollisionUtil.h>

const al::CollisionParts* rs::getCollidedGroundCollisionParts(const IUsePlayerCollision*)

#include <Util/PlayerCollisionUtil.h>

const sead::Vector3f& rs::getCollidedCeilingPos(const IUsePlayerCollision*)

#include <Util/PlayerCollisionUtil.h>

const sead::Vector3f& rs::getCollidedCeilingNormal(const IUsePlayerCollision*)

#include <Util/PlayerCollisionUtil.h>

const al::CollisionParts* rs::getCollidedCeilingCollisionParts(const IUsePlayerCollision*)

#include <Util/PlayerCollisionUtil.h>

bool rs::isCollidedGround(const IUsePlayerCollision*)

#include <Util/PlayerCollisionUtil.h>

bool rs::isCollidedGroundRunAngle(const al::LiveActor*, const IUsePlayerCollision*, const PlayerConst*)

#include <Util/PlayerCollisionUtil.h>

bool rs::isOnGroundSlopeSlideStart(const al::LiveActor*, const IUsePlayerCollision*, const PlayerConst*)

#include <Util/PlayerCollisionUtil.h>

bool rs::isOnGroundForceSlideCode(const al::LiveActor*, const IUsePlayerCollision*, const PlayerConst*)

#include <Util/PlayerCollisionUtil.h>

bool rs::isOnGroundForceRollingCode(const al::LiveActor*, const IUsePlayerCollision*)

#include <Util/PlayerCollisionUtil.h>

bool rs::isOnGroundLessAngle(const al::LiveActor*, const IUsePlayerCollision*, f32)

#include <Util/PlayerCollisionUtil.h>

bool rs::isPlayerOnGround(const al::LiveActor*)

#include <Util/PlayerCollisionUtil.h>

bool rs::isOnGround(const al::LiveActor*, const IUsePlayerCollision*)

#include <Util/PlayerCollisionUtil.h>

bool rs::isJustLand(const IUsePlayerCollision*)

#include <Util/PlayerCollisionUtil.h>

void rs::calcGroundNormalOrGravityDir(sead::Vector3f*, const al::LiveActor*, const IUsePlayerCollision*)

#include <Util/PlayerCollisionUtil.h>

bool rs::isCollisionCodeSandSink(const IUsePlayerCollision*)

#include <Util/PlayerCollisionUtil.h>

bool rs::isCollidedWall(const IUsePlayerCollision*)

#include <Util/PlayerCollisionUtil.h>

bool rs::isCollidedCeiling(const IUsePlayerCollision*)

#include <Util/PlayerCollisionUtil.h>

bool rs::isActionCodeNoWallGrab(const IUsePlayerCollision*)

#include <Util/PlayerCollisionUtil.h>

bool rs::isActionCodeNoActionWall(const IUsePlayerCollision*)

#include <Util/PlayerCollisionUtil.h>

bool rs::isCollisionCodeGrabCeilAny(const IUsePlayerCollision*)

#include <Util/PlayerCollisionUtil.h>

bool rs::isCollisionCodeGrabCeilWall(const IUsePlayerCollision*)

#include <Util/PlayerCollisionUtil.h>

bool rs::isCollisionCodeGrabCeilCeiling(const IUsePlayerCollision*)

#include <Util/PlayerCollisionUtil.h>

bool rs::isCollisionCodeGrabCeilGrround(const IUsePlayerCollision*)

#include <Util/PlayerCollisionUtil.h>

void rs::setColliderFilterCollisionParts(IUsePlayerCollision*, const al::CollisionPartsFilterBase*)

#include <Util/PlayerCollisionUtil.h>

bool rs::reboundVelocityFromCollision(al::LiveActor*, const IUsePlayerCollision*, f32, f32, f32)

#include <Util/PlayerCollisionUtil.h>

al::HitSensor* rs::tryGetCollidedCeilingSensor(const IUsePlayerCollision*)

#include <Util/PlayerCollisionUtil.h>

bool rs::isOnGroundSlopeSlideEnd(const al::LiveActor*, const IUsePlayerCollision*, const PlayerConst*)

#include <Util/PlayerCollisionUtil.h>

bool rs::isAutoRunOnGroundSkateCode(const al::LiveActor*, const IUsePlayerCollision*, f32)

#include <Util/PlayerCollisionUtil.h>

IUsePlayerPuppet* rs::startPuppet(al::HitSensor* actorHitSensor, al::HitSensor* playerHitSensor)

#include <Util/PlayerPuppetFunction.h>

void rs::endBindAndPuppetNull(IUsePlayerPuppet** playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::endBindOnGroundAndPuppetNull(IUsePlayerPuppet** playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::endBindJumpAndPuppetNull(IUsePlayerPuppet** playerPuppet, const sead::Vector3f& endTrans, s32 timeBeforeEnd)

#include <Util/PlayerPuppetFunction.h>

void rs::endBindWallJumpAndPuppetNull(IUsePlayerPuppet** playerPuppet, const sead::Vector3f& endTrans, s32 timeBeforeEnd)

#include <Util/PlayerPuppetFunction.h>

void rs::endBindCapThrow(IUsePlayerPuppet** playerPuppet)

#include <Util/PlayerPuppetFunction.h>

bool rs::tryReceiveBindCancelMsgAndPuppetNull(IUsePlayerPuppet** playerPuppet, const al::SensorMsg* msg)

#include <Util/PlayerPuppetFunction.h>

void rs::setPuppetTrans(IUsePlayerPuppet* playerPuppet, const sead::Vector3f& trans)

#include <Util/PlayerPuppetFunction.h>

void rs::setPuppetVelocity(IUsePlayerPuppet* playerPuppet, const sead::Vector3f& velocity)

#include <Util/PlayerPuppetFunction.h>

void rs::setPuppetFront(IUsePlayerPuppet* playerPuppet, const sead::Vector3f& front)

#include <Util/PlayerPuppetFunction.h>

void rs::calcPuppetUp(sead::Vector3f* up, const IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::setPuppetUp(IUsePlayerPuppet* playerPuppet, const sead::Vector3f& up)

#include <Util/PlayerPuppetFunction.h>

void rs::calcPuppetFront(sead::Vector3f* front, const IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::setPuppetQuat(IUsePlayerPuppet* playerPuppet, const sead::Quatf& quat)

#include <Util/PlayerPuppetFunction.h>

void rs::resetPuppetPosition(IUsePlayerPuppet* playerPuppet, const sead::Vector3f& trans)

#include <Util/PlayerPuppetFunction.h>

void rs::addPuppetVelocityFall(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

const sead::Vector3f& rs::getPuppetGravity(const IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

const sead::Vector3f& rs::getPuppetVelocity(const IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

const sead::Vector3f& rs::getPuppetTrans(const IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::calcPuppetQuat(sead::Quatf* quat, const IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::startPuppetAction(IUsePlayerPuppet* playerPuppet, const char* action)

#include <Util/PlayerPuppetFunction.h>

bool rs::isPuppetActionEnd(const IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

bool rs::isPuppetActionPlaying(const IUsePlayerPuppet* playerPuppet, const char* action)

#include <Util/PlayerPuppetFunction.h>

void rs::setPuppetAnimRate(IUsePlayerPuppet* playerPuppet, f32 animRate)

#include <Util/PlayerPuppetFunction.h>

void rs::setPuppetAnimBlendWeight(IUsePlayerPuppet* playerPuppet, f32 weight1, f32 weight2, f32 weight3, f32 weight4, f32 weight5, f32 weight6)

#include <Util/PlayerPuppetFunction.h>

f32 rs::getPuppetAnimFrameMax(const IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::startPuppetHitReactionLand(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::hidePuppet(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::showPuppet(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

bool rs::isPuppetHidden(const IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::syncPuppetVisibility(al::LiveActor* actor, const IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::hidePuppetSilhouette(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::showPuppetSilhouette(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::hidePuppetShadow(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::showPuppetShadow(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::validatePuppetSensor(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::invalidatePuppetSensor(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::invalidatePuppetCollider(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

bool rs::isCollidedPuppetGround(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

const sead::Vector3f& rs::getCollidedPuppetGroundNormal(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::validatePuppetCollider(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::requestDamage(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::clearStainEffect(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::copyPuppetDitherAlpha(IUsePlayerPuppet* playerPuppet, const al::LiveActor* actor)

#include <Util/PlayerPuppetFunction.h>

void rs::validatePuppetLookAt(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::invalidatePuppetLookAt(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::validatePuppetForceLookAt(IUsePlayerPuppet* playerPuppet, const sead::Vector3f& lookAt)

#include <Util/PlayerPuppetFunction.h>

void rs::invalidatePuppetForceLookAt(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::validatePuppetSeparateMode(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::invalidatePuppetSeparateMode(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::validatePuppetReceivePush(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::invalidatePuppetReceivePush(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::forcePutOnPuppetCap(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::forcePutOnPuppetCapWithEffect(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::setForceRunAfterEndBind(IUsePlayerPuppet* playerPuppet, s32, f32)

#include <Util/PlayerPuppetFunction.h>

void rs::validateRecoveryArea(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::invalidateRecoveryArea(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::validateGuideArrow(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::invalidateGuideArrow(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::validateWaterSurfaceShadow(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::invalidateWaterSurfaceShadow(IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

bool rs::isPuppetInputCapThrow(const IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

bool rs::isPuppetInputSwing(const IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

BindKeepDemoInfo* rs::initBindKeepDemoInfo()

#include <Util/PlayerPuppetFunction.h>

bool rs::isActiveBindKeepDemo(const BindKeepDemoInfo* bindKeepDemoInfo)

#include <Util/PlayerPuppetFunction.h>

bool rs::tryStartBindKeepDemo(BindKeepDemoInfo* bindKeepDemoInfo, const al::SensorMsg* msg, const IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

bool rs::tryEndBindKeepDemo(BindKeepDemoInfo* bindKeepDemoInfo, const al::SensorMsg* msg, IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

bool rs::isPuppetTrigJumpButton(const IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

bool rs::isPuppetHoldJumpButton(const IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

bool rs::isPuppetTrigActionButton(const IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

bool rs::isPuppetHoldActionButton(const IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

bool rs::isPuppetTriggerAnyButton(const IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

bool rs::isPuppetHoldAnyButton(const IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

bool rs::isPuppetMoveStickOn(const IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

bool rs::isPuppetStartWorldWarp(const IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

bool rs::isPuppetCancelWorldWarp(const IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

const sead::Vector2f& rs::getPuppetMoveStick(const IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

bool rs::isTriggerGetOff(const IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

f32 rs::getPuppetPoseRotZDegreeLeft(const IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

f32 rs::getPuppetPoseRotZDegreeRight(const IUsePlayerPuppet* playerPuppet)

#include <Util/PlayerPuppetFunction.h>

void rs::requestUpdateSafetyPoint(IUsePlayerPuppet* playerPuppet, const al::LiveActor* actor, const IUsePlayerCollision* playerCollision)

#include <Util/PlayerPuppetFunction.h>

void rs::requestForceSafetyPoint(IUsePlayerPuppet* playerPuppet, const sead::Vector3f& recoveryTrans, const sead::Vector3f& recoveryNormal)

#include <Util/PlayerPuppetFunction.h>

void rs::initPlayerActorInfo(PlayerActorBase*, const PlayerInitInfo&)

#include <Util/PlayerUtil.h>

const char* rs::getInitPlayerModelName(const PlayerInitInfo&)

#include <Util/PlayerUtil.h>

bool rs::isNeedCreateNoseNeedle(const PlayerInitInfo&)

#include <Util/PlayerUtil.h>

bool rs::isClosetScenePlayer(const PlayerInitInfo&)

#include <Util/PlayerUtil.h>

al::GamePadSystem* rs::getGamePadSystem(const PlayerInitInfo&)

#include <Util/PlayerUtil.h>

const char* rs::getInitCapTypeName(const PlayerInitInfo&)

#include <Util/PlayerUtil.h>

al::SklAnimRetargettingInfo* rs::createPlayerSklRetargettingInfo(al::LiveActor*, const sead::Vector3f&)

#include <Util/PlayerUtil.h>

const sead::Vector3f& rs::getPlayerPos(const al::LiveActor*)

#include <Util/PlayerUtil.h>

const sead::Vector3f& rs::getPlayerHeadPos(const al::LiveActor*)

#include <Util/PlayerUtil.h>

const sead::Vector3f& rs::getPlayerBodyPos(const al::LiveActor*)

#include <Util/PlayerUtil.h>

void rs::calcPlayerSideDir(sead::Vector3f*, const al::LiveActor*)

#include <Util/PlayerUtil.h>

void rs::calcPlayerUpDir(sead::Vector3f*, const al::LiveActor*)

#include <Util/PlayerUtil.h>

void rs::calcPlayerFrontDir(sead::Vector3f*, const al::LiveActor*)

#include <Util/PlayerUtil.h>

void rs::calcPlayerGroundPoseUp(sead::Vector3f*, const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isNearPlayerH(const al::LiveActor*, f32)

#include <Util/PlayerUtil.h>

void rs::calcPlayerFollowLayoutWorldPos(sead::Vector3f*, const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHack(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackGroupUseCameraStick(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::tryCalcPlayerCeilingSpace(f32*, const al::LiveActor*, f32, f32)

#include <Util/PlayerUtil.h>

bool rs::tryCalcKidsGuideCeilingSpace(f32*, const al::LiveActor*, f32, f32)

#include <Util/PlayerUtil.h>

const sead::Vector3f& rs::getPlayerVelocity(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::tryCalcPlayerModelHeadJointPos(sead::Vector3f*, const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::tryCalcPlayerModelHeadJointUp(sead::Vector3f*, const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::tryCalcPlayerModelHeadJointFront(sead::Vector3f*, const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::tryCalcPlayerModelHeadJointSide(sead::Vector3f*, const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::tryCalcPlayerModelNoseJointMtx(sead::Matrix34f*, const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerDamageStopDemo(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackType(const al::LiveActor*, s32)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackRigidBody(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackJugemFishing(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackKuriboAny(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackKuribo(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackKuriboWing(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackStatueMario(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackEnemy(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackTrilemmaRock(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackTrilemmaPaper(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackTrilemmaScissors(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackElectricWire(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackTRex(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackFukankun(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackHosui(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackYoshi(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackYukimaru(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackHammerBros(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackBazookaElectric(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackBubble(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackTank(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackTsukkun(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackPukupuku(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackPukupukuAll(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackRadiconNpc(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackSenobi(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackKakku(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackGroupTalkScare(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerHackNoSeparateCameraInput(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerEnableToSeeOddSpace(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerMini(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayer3D(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayer2D(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerSquat(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerInWater(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerPoleClimb(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerWallCatch(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerCameraSubjective(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerEnableTalkGround(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerEnableTalkSwim(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerBinding(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerEquipSomething(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerEquipRocketFlower(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerEquipNoSeparateAction(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerCarrySomething(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerNoInput(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerEnableShowTutorialInput(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerSafetyPointRecovery(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerPlayingSwitchOnAnim(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerEquipNoSeparateTutorial(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerWaitSleep(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerAboveSeparateCapGuideArrow(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerInvalidateGuideArrow(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerInvisibleCap(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerEnablePeachAmiibo(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerActiveMarioAmiiboInvincible(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerCollidedGround(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerCollidedCeiling(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerOnActor(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerOnChairActor(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerOnBedActor(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerFaceToTarget(const al::LiveActor*, const sead::Vector3f&)

#include <Util/PlayerUtil.h>

bool rs::isPlayerFaceToTarget(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerFaceToTargetInRange(const al::LiveActor*, const sead::Vector3f&, f32)

#include <Util/PlayerUtil.h>

bool rs::isPlayerFaceToTargetInRange(const al::LiveActor*, f32)

#include <Util/PlayerUtil.h>

bool rs::tryGetFlyingCapPos(sead::Vector3f*, const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::tryGetFlyingCapVelocity(sead::Vector3f*, const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isEnableReceiveCapStartLockOnAngle(const al::LiveActor*, const al::HitSensor*)

#include <Util/PlayerUtil.h>

bool rs::isEquipCapCatched(const al::LiveActor*)

#include <Util/PlayerUtil.h>

f32 rs::getFlyingCapThrowSpeedMax(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerCapSpinOrFlying(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerCapFlying(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerCapSeparateThrow(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isEmptyPlayerOxygen(const al::LiveActor*)

#include <Util/PlayerUtil.h>

void rs::recoveryPlayerOxygen(const al::LiveActor*)

#include <Util/PlayerUtil.h>

void rs::requestBindPlayer(const al::LiveActor*, al::HitSensor*)

#include <Util/PlayerUtil.h>

void rs::sendMsgBreakFloorToPlayer(const al::LiveActor*)

#include <Util/PlayerUtil.h>

void rs::requestStageStartHack(const al::LiveActor*, al::HitSensor*, const CapTargetInfo*, al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isEnableOpenMap(const al::LiveActor*)

#include <Util/PlayerUtil.h>

void rs::syncPlayerModelAlpha(al::LiveActor*)

#include <Util/PlayerUtil.h>

f32 rs::getPlayerShadowDropLength(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isExistLabelInPlayerHackSystemMstxt(const al::LiveActor*, const al::IUseMessageSystem*, const char*, const char*)

#include <Util/PlayerUtil.h>

const char16* rs::getPlayerHackSystemMessageString(const al::LiveActor*, const al::IUseMessageSystem*, const char*, const char*)

#include <Util/PlayerUtil.h>

void rs::getPlayerHackTutorialMoviePath(al::StringTmp<64>*, const al::LiveActor*, const char*)

#include <Util/PlayerUtil.h>

void rs::calcPlayerAmiiboPeachAppearBasePos(sead::Vector3f*, const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerInputHoldBalloonSet(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerInputHoldSquat(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerInputHoldCapKeepLockOn(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerInputHoldCarryAction(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerInputHoldEnterUpperDokan2D(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerInputHoldEnterSideDokan2D(const al::LiveActor*, const sead::Vector3f&)

#include <Util/PlayerUtil.h>

bool rs::isPlayerInputTriggerStartTalk(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerInputTriggerRide(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isPlayerInputTriggerSeparateCapJangoHelp(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::tryGetPlayerInputWallAlongWallNormal(sead::Vector3f*, const al::LiveActor*)

#include <Util/PlayerUtil.h>

void rs::calcPlayerHoldPos(sead::Vector3f*, const al::HitSensor*)

#include <Util/PlayerUtil.h>

void rs::calcPlayerHoldMtx(sead::Matrix34f*, const al::HitSensor*)

#include <Util/PlayerUtil.h>

void rs::setPlayerHoldJointAngle(const al::HitSensor*, const sead::Vector3f&)

#include <Util/PlayerUtil.h>

void rs::updatePosePlayerHold(al::LiveActor*, const al::HitSensor*)

#include <Util/PlayerUtil.h>

void rs::updatePosePlayerHoldAddOffset(al::LiveActor*, const al::HitSensor*, const sead::Vector3f&)

#include <Util/PlayerUtil.h>

f32 rs::calcPlayerGuideOffsetY(const al::LiveActor*)

#include <Util/PlayerUtil.h>

bool rs::isEnablePlayerHeadGuide(const al::LiveActor*)

#include <Util/PlayerUtil.h>

void rs::calcPlayerGuidePos(sead::Vector3f*, const al::LiveActor*)

#include <Util/PlayerUtil.h>

void rs::calcPlayerGuidePos(sead::Vector3f*, const al::LiveActor*, f32)

#include <Util/PlayerUtil.h>

bool rs::trySavePrepoCompleteMainScenario(s32, s32, s64, s64, s64)

#include <Util/ScenePrepoFunction.h>

bool rs::trySavePrepoStartStage(const char*, const sead::Vector3f&, s64, s64, s64)

#include <Util/ScenePrepoFunction.h>

bool rs::trySavePrepoExitStage(const char*, const sead::Vector3f&, s64, s64, s64)

#include <Util/ScenePrepoFunction.h>

bool rs::trySavePrepoMissEvent(const char*, const sead::Vector3f&, s64, s64, s64)

#include <Util/ScenePrepoFunction.h>

bool rs::trySavePrepoShineGetEvent(const char*, s32, s32, s32, s64, s64, s64)

#include <Util/ScenePrepoFunction.h>

bool rs::trySavePrepoReceiveAchievement(const char* s32, s64, s64, s64)

#include <Util/ScenePrepoFunction.h>

bool rs::trySavePrepoAchievementProgress(GameDataHolderAccessor, s64, s64, s64)

#include <Util/ScenePrepoFunction.h>

bool rs::trySavePrepoGetCapEvent(const char*, s32, s64, s64, s64)

#include <Util/ScenePrepoFunction.h>

bool rs::trySavePrepoGetClothEvent(const char*, s32, s64, s64, s64)

#include <Util/ScenePrepoFunction.h>

bool rs::trySavePrepoGetGiftEvent(const char*, s32, s64, s64, s64)

#include <Util/ScenePrepoFunction.h>

bool rs::trySavePrepoGetStickerEvent(const char*, s32, s64, s64, s64)

#include <Util/ScenePrepoFunction.h>

bool rs::trySavePrepoChangeCapEvent(const char*, s64, s64, s64)

#include <Util/ScenePrepoFunction.h>

bool rs::trySavePrepoChangeClothEvent(const char*, s64, s64, s64)

#include <Util/ScenePrepoFunction.h>

bool rs::trySavePrepoFirstHackEvent(const char*, s32, s64, s64, s64)

#include <Util/ScenePrepoFunction.h>

bool rs::trySavePrepoGetCollectBgmEvent(const char*, const char*, bool, s32, s64, s64, s64)

#include <Util/ScenePrepoFunction.h>

bool rs::trySavePrepoSettingsState(bool, const char*, const GameConfigData&, s64, s64)

#include <Util/ScenePrepoFunction.h>

bool rs::trySavePrepoSeparatePlayMode(bool, s64, s64, s64)

#include <Util/ScenePrepoFunction.h>

bool rs::sendMsgAckCheckpoint(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgAckGetShine(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgAckLifeUp(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgAckLifeMaxUp(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgAskRailCollision(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBreakPartsBreak(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBirdFlyAway(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCameraAngleElevationResetFast(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgChorobonAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgConductLightning(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgDamageBallAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgDamageBallBodyAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgDonsukeAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgDonsukeGroundAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgDonsukePush(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgDragonAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgEatExplosion(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgElectricWireNoLimitDistance(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgEnemyAttack2D(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgEnemyAttack3D(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgEnemyAttackDash(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHackAttackFire(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgEnemyAttackFireCollision(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgEnemyAttackPoison(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgEnemyAttackTRex(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHackAttackPoison(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgConfirmPaintObj(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgConfirmPaintObjForSeed(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPaintAttackPoison(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgEnemyKick(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgRabbitKick(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgFishingAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgFishingCancel(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgFishingFishApproach(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgFishingFishFloatTouch(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgFishingItemGet(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgFishingLineTouch(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgFishingStart(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgFishingUpImmediatelyPrepare(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgFireBrosFireBallCollide(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgFireSwitchFire(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgFrogHackTrample(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGhostRecordStart(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGhostRecordEnd(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGhostPlay(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGhostStop(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGiantWanderBossAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGiantWanderBossBulletAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGiantWanderBossBulletPush(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGhostReverse(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGhostCancel(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGrowFlowerSeedDisablePush(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGrowFlowerSeedNear(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGrowPlantPush(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGrowerAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGrowerWallAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGunetterAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGunetterBodyTouch(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHammerAttackDown(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHammerAttackSide(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHammerAttackSideCollide(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgItemAmiiboKoopa(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgIsExistPukupuku(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgJangoAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgJangoRemoveCap(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKakkuKick(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKillByBossBattleDemo(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKillByHackFirstDemo(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKillByHomeDemo(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgEndHomeDemo(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKillByMoonRockDemo(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKillByShineGet(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKillBySwitchTimer(al::LiveActor*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKoopaBindStart(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKoopaCapPlayerFocusTarget(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKoopaCapPunchFinishL(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKoopaCapPunchFinishR(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKoopaCapPunchInvincibleL(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKoopaCapPunchInvincibleR(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKoopaCapPunchKnockBackL(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKoopaCapPunchKnockBackR(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKoopaCapPunchL(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKoopaCapPunchR(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKoopaCapSpinAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKoopaCatchKoopaCap(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKoopaDashPunchAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKoopaFire2D(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKoopaFireBallAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKoopaHackDamage(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKoopaHackPunch(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKoopaHackPunchCollide(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKoopaHackTrample(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKoopaInvalidHackPunchFaceToCollision(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKoopaRingBeamInvalidTouch(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKoopaTailAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKoopaTouchFloor(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKouraAttack2D(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKouraItemGet2D(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgLaunchBlow(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgMeganeAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgMeganeHackTrample(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgMofumofuBulletUnexplosion(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgMoonBasementAttackMeteor(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgMoonBasementBreakShockwaveMeteor(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgMoonBasementRockSyncClippingRegist(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgMoonBasementRockSyncClippingInvalidate(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgMoonBasementRockSyncClippingValidate(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgAttachCactusNeedle(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCactusNeedleAttack(al::HitSensor* source, al::HitSensor* target, al::ComboCounter*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCactusNeedleAttackStrong(al::HitSensor* source, al::HitSensor* target, al::ComboCounter*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerBallToss(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerCarryCameraSubjectiveStart(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerCarryCameraSubjectiveEnd(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerCarryShineGetStart(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerCarryShineGetEnd(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerCapCatch(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerCapHipDrop(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerCapPush(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerCapRecovery(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerCapTouchJump(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerCapTrample(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerCoinDashGet(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerEyePriorityTarget(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerDisregardHomingAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerDisregardTargetMarker(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerEquipKoopaCap(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerFireBallAttack2D(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerFireBallAttack3D(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerHipDropDemoTrigger(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerHipDropHipDropSwitch(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerItemGet2D(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerJumpTakeOffFloor(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerObjectWallHit(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerObjLeapFrog(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerPenguinAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerPenguinAttackReflect(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerPoleClimbKeep(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerPoleClimbReaction(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerRabbitGet(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerRollingObjHit(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerRollingWallHitDown(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerRollingWallHitMove(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerStartGrabCeil(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerStartWallJump(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerEndGrabCeil(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerSwordAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerTouchFloorJumpCode(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerTrample2D(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerUpperPunch2D(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerObjUpperPunch2D(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPukupukuDash(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPukupukuKiss(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPukupukuRollingAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPush2D(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPushToFish(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPushToMotorcycle(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPushToPlayer(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgRadishAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgRadishReflect(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgRequestChangeKinokoSuper(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgRequestChangeFireFlower(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgRequestPlayerSandMoon(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgRequestPlayerSnow(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgRequestPlayerWet(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgStartHack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgSunshineAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCancelHack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCancelHackArea(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCancelHackByDokan(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPackunEatStart(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHackAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHackAttackKick(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHackAttackMapObj(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHackDeathAreaSelfCheck(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHackDemoEnd(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHackDemoStart(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHackInvalidEscape(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHackInvalidEscapeNoReaction(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHackMarioCheckpointFlagWarp(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHackMarioDead(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHackMarioDemo(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHackMarioInWater(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHackMoveRockForestPush(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHackSelfCeilingCheckMiss(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHackSyncDamageVisibility(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgWeaponItemGet(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCapAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCapAttackCollide(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCapAttackStayRolling(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCapAttackStayRollingCollide(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCapAttackRailMove(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCapGiantAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCapReflect(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCapReflectCollide(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCapStartLockOn(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCapKeepLockOn(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCapCancelLockOn(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCapHipDrop(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCapObjHipDrop(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCapObjHipDropReflect(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCapIgnoreCancelLockOn(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCapIgnoreCancelMissReaction(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCapIgnoreCollisionCheck(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCapItemGet(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCapTrampolineAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCatchBombThrough(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCheckCarObstacle(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCheckIsCardboardBox(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBullHackAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBullEnemyAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgEnemyAttackStrong(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgEnemyObjBreak(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgWhipAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgNoLimitTouchJump(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgNoticePlayerDamage(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgStatueDrop(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgStatueTrampleReflect(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgStatuePush(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgStatueSnap(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHitGrowFlowerPot(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHitGrowPlantPot(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgImplantGrowFlowerSeed(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgIcicleAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgIgnoreMirrorWarp(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgIgnoredByRunawayNpc(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgIgnorePushMotorcycle(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgSandSharkAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgSeedAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgSeedAttackBig(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgSeedAttackHold(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgSeedItemGet(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgSeedReflect(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgSenobiTrample(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgSenobiCancelStretch(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgSenobiPunchBlockTransparent(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgShibakenApproach(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgShibakenKick(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHackUpperPunch(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHackObjUpperPunch(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgShineGet(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgShineGet2D(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgSpherePush(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, f32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgSphinxJumpAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgSphinxQuizRouteKill(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgSphinxRideAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgSphinxRideAttackReflect(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPechoSpot(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBelowObjBroken(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBindCollidedGround(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBindKeepDemoStart(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBindKeepDemoExecute(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBindKeepDemoEnd(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBindRecoveryLife(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgMayorItemReflect(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgMayorItemCollide(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBlowObjAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBlowObjAttackReflect(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgConfirmFrailBox(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgConfirmBrokenFrailBox(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTankLookOn(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTankKickHack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTankKickEnemy(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTankBullet(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTankBulletNoReaction(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTimerAthleticDemoStart(al::LiveActor*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgRideOnStart(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgRideOnEnd(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgRideOnRelease(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHipDropTransformTransform(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHipDropTransformReverse(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHipDropTransformingUp(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHipDropTransformingDown(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHipDropTransformingFinish(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgClearFire(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCollectAnimalTouchCollide(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBossKnuckleCounter(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBossKnuckleFallAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBossKnuckleHackAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBossKnuckleKillerAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBossKnuckleIceConflict(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBossKnuckleIceFallToMummy(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgSkaterAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgEnableInSaucePan(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgEnableMapCheckPointWarp(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgStartInSaucePan(al::HitSensor* source, al::HitSensor* target, bool)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgEndInSaucePan(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgLineDancerLink(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgLongPushSensorHit(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgLongPushBoxHit(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGoldHammerAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTrashBoxIn(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTouchDoorDrumn(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKuribo2DTouch(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKuriboCollisionDamage(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKuriboCollisionKill(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKuriboFlick(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKuriboTowerOn(al::HitSensor* source, al::HitSensor* target, u32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPartyPopperSoundAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgYokinBallAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgYoshiDirectEat(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgYoshiTongueAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgYoshiTongueEatBind(al::HitSensor* source, al::HitSensor* target, f32*, f32*, f32*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgYoshiTongueEatBindCancel(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgYoshiTongueEatBindFinish(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgYoshiTongueEatHomingTarget(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgYukimaruPush(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPunchMachinePunchStraight(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPunchMachinePunchHook(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPunchMachinePunchUpper(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgMorningStarWarpStart(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgMorningStarWarpEnd(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGemyAim(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHammerBrosHammerEnemyAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHammerBrosHammerHackAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHammerBrosHammerSearch(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHackBrosContact(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgMotorcycleAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgMotorcycleCollideParkingLot(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgMotorcycleDashAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgMotorcycleDashCollide(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgWanwanEnemyAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgWanwanPush(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgWanwanReboundAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgWanwanBlockAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgWanwanHoleIn(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgWaterRoadIn(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgWaterRoadNear(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBreedaSlap(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBreedaPush(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGamaneBullet(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGamaneBulletThrough(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGamaneBulletForCoinFlower(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgVolleyballNpcScareByEnemy(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgRocketFlowerExtension(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgWanderBossCameraRange(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKuriboGirlAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKuriboGirlLove(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKuriboTop(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTRexAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTRexAttackCollideBody(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTRexAttackCollideHead(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTRexDashAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTRexScrollPartsBreakWith(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTsukkunNoTrace(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTouchFireDrum2D(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPropellerAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTankExplosion(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTankHackTrample(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgUtsuboAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKillerAttackNoExplode(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKillerMagnumAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgKillerMagnumHackAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGabuzouAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgStackerRollingAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgStackerCapBoostAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgIgnoreIgnitionBomb(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgExplosionReflectBomb(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGolemStampPress(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgSwitchOnWithSaveRequest(al::LiveActor*, SaveObjInfo*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgWanwanReboundAttackToCollided(const al::LiveActor*, al::HitSensor*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgWanwanBlockAttackToCollided(const al::LiveActor*, al::HitSensor*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgDigPointSmell(al::HitSensor* source, al::HitSensor* target, DigPoint*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgMofumofuBodyChainExplode(al::HitSensor* source, al::HitSensor* target, s32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgMoonBasementRockThroughCollision(al::HitSensor* source, al::HitSensor* target, bool)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgFishingWait(al::HitSensor* source, al::HitSensor* target, al::HitSensor*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgFishingUpImmediately(al::HitSensor* source, al::HitSensor* target, const sead::Matrix34f&, const sead::Vector3f&, const char*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGunetterPush(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, f32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTestPunch(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, s32, s32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTestPunchStrong(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, s32, s32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPunchGuard(al::HitSensor* source, al::HitSensor* target, s32, s32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTsukkunThrust(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, s32, bool)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTsukkunThrustSpin(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, s32, bool)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTsukkunThrustReflect(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, s32, bool)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTsukkunThrustCollide(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, s32, bool)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTsukkunThrustHitReflectCollide(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, s32, bool)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTsukkunThrustReflectCollide(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, s32, bool)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTsukkunThrustHole(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, const sead::Vector3f&)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTsukkunThroughCollide(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTsukkunHoldCollide(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTsukkunForceCancelCollide(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgNetworkShootingShot(al::HitSensor* source, al::HitSensor* target, s32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgNetworkShootingChargeShot(al::HitSensor* source, al::HitSensor* target, s32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgRequestPlayerJumpBreakFloor(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgRequestPlayerJump(al::HitSensor* source, al::HitSensor* target, f32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgRequestPlayerTrampleJump(al::HitSensor* source, al::HitSensor* target, f32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgRequestPlayerSpinJump(al::HitSensor* source, al::HitSensor* target, f32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgRequestSphinxJump(al::HitSensor* source, al::HitSensor* target, f32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgIgnoreTouchTarget(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgIgnoreTouchTarget(al::ScreenPointer*, al::ScreenPointTarget*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgInitTouchTargetInfo(al::HitSensor* source, al::HitSensor* target, TouchTargetInfo*, const sead::Vector3f*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgInitTouchTargetInfo(al::ScreenPointer*, al::ScreenPointTarget*, TouchTargetInfo*, const sead::Vector3f*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCollisionImpulse(al::HitSensor* source, al::HitSensor* target, sead::Vector3f*, const sead::Vector3f&, f32, const sead::Vector3f&, f32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgWhipHold(al::HitSensor* source, al::HitSensor* target, WhipTargetInfo*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgWhipBind(al::HitSensor* source, al::HitSensor* target, WhipTargetInfo*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgWhipThrow(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgMagnet(al::HitSensor* source, al::HitSensor* target, bool)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgMagnetBulletAttack(al::HitSensor* source, al::HitSensor* target, f32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgDashPanel(al::HitSensor* source, al::HitSensor* target, s32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTrampolineCrackJump(al::HitSensor* source, al::HitSensor* target, f32, f32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCapTouchWall(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, const sead::Vector3f&)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCapRethrow(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCapRethrowReturnOnly(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCapChangeGiant(al::HitSensor* source, al::HitSensor* target, f32, s32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPackunEatCancel(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, const sead::Vector3f&)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPackunEatEnd(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, const sead::Vector3f&)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPackunEatStartFollow(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgFireBlowerAttack(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPaint(al::HitSensor* source, al::HitSensor* target, const sead::Color4u8&, s32, s32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPaintTexture(al::HitSensor* source, al::HitSensor* target, s32, f32, s32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCheckPaintClear(al::HitSensor* source, al::HitSensor* target, const sead::Color4u8&, const sead::Vector3f&, s32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCheckPaintAlpha(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgByugoBlow(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHackDirectStageInit(al::HitSensor* source, al::HitSensor* target, IUsePlayerHack*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgObjSnapForce(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCapBeamerBeam(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHosuiAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHosuiAttackCollide(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHosuiAttackNoEffect(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHosuiAttackStrong(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHosuiTouch(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHosuiTrample(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHosuiTrampleReflect(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHosuiTrampleReflectHigh(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBubbleAttack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBubbleAttackToPecho(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBubbleReflectH(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBubbleReflectV(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBubbleWallTouch(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBubbleGroundTouchTrigger(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBubbleLauncherStart(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgSenobiPartsMove(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, f32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgStampTo2D(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgAirExplosion(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPushVelocity(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGhostRecordStartOk(al::HitSensor* source, al::HitSensor* target, const char*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgSandGeyserRaise(al::HitSensor* source, al::HitSensor* target, f32, f32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgRaceWait(al::LiveActor*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgRaceStart(al::LiveActor*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgRaceStop(al::LiveActor*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgRaceReturnToCourse(al::LiveActor*, const sead::Vector3f&, const sead::Vector3f&)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerLookAtPosition(al::HitSensor* source, al::HitSensor* target, sead::Vector3f*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTargetMarkerPosition(al::HitSensor* source, al::HitSensor* target, sead::Vector3f*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgHackBlowJump(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, f32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGolemStampPushV(al::HitSensor* source, al::HitSensor* target, f32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGolemStampPushH(al::HitSensor* source, al::HitSensor* target, f32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgRequestPlayerWaitAnimDigPoint(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgEventFlowScareCheck(al::HitSensor* source, al::HitSensor* target, al::EventFlowExecutor*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerItemGetAll(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPlayerItemGetAll2D(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTRexAttackAll(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgSeedTouch(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, const sead::Vector3f&)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgSphinxRideAttackTouchThrough(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, const sead::Vector3f&)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgSphinxRideAttackTouch(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, const sead::Vector3f&)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgAckCheckpoint(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgAckGetShine(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgAckLifeUp(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgAckLifeMaxUp(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgAskRailCollision(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgAttachCactusNeedle(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgAirExplosion(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBelowObjBroken(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBindCollidedGround(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBindKeepDemoStart(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBindKeepDemoExecute(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBindKeepDemoEnd(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBindRecoveryLife(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBirdFlyAway(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBlowObjAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgMayorItemCollide(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgMayorItemReflect(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBlowObjAttackReflect(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBossKnuckleCounter(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBossKnuckleFallAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBossKnuckleHackAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBossKnuckleIceConflict(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBossKnuckleIceFallToMummy(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBossKnuckleKillerAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBreakPartsBreak(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBreedaSlap(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBreedaPush(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBubbleAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBubbleAttackToPecho(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBubbleLauncherStart(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBubbleReflectH(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBubbleReflectV(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBubbleWallTouch(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBubbleGroundTouchTrigger(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBullAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBullHackAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBullEnemyAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgByugoBlow(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCameraAngleElevationResetFast(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCancelHack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCancelHackArea(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCancelHackByDokan(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCapAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCapAttackCollide(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCapAttackRailMove(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCapAttackStayRolling(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCapAttackStayRollingCollide(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCapBeamerBeam(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCapCancelLockOn(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCapChangeGiant(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCapEnableLockOn(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCapStartLockOn(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCapKeepLockOn(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCapGiantAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCapHipDrop(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCapObjHipDrop(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCapObjHipDropReflect(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCapIgnoreCancelLockOn(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCapIgnoreCancelMissReaction(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCapIgnoreCollisionCheck(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCapItemGet(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCapReflect(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCapReflectCollide(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCapRethrow(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCapTouchWall(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCapTrampolineAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCatchBombThrough(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCheckCarObstacle(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCheckIsCardboardBox(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgChorobonAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgClearFire(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCollectAnimalTouchCollide(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCollisionImpulse(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgConductLightning(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgConfirmFrailBox(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgConfirmBrokenFrailBox(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgDamageBallAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgDamageBallBodyAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgDigPointSmell(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgDonsukeAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgDonsukeGroundAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgDonsukePush(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgDragonAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgEatExplosion(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgElectricWireNoLimitDistance(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgEnableInSaucePan(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgEnableMapCheckPointWarp(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgEndInSaucePan(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgEnemyAttack2D(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgEnemyAttack3D(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgEnemyAttackDash(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgFireBrosFireBallCollide(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgFireDamageAll(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHackAttackFire(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgFireSwitchFire(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgEnemyAttackFireCollision(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgEnemyAttackTRex(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPoisonDamageAll(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgEnemyAttackPoison(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHackAttackPoison(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPaintAttackPoison(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgConfirmPaintObj(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgConfirmPaintObjForSeed(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgEnemyAttackStrong(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgEnemyKick(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgRabbitKick(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgEnemyObjBreak(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgFireBlowerAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgFishingAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgFishingCancel(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgFishingFishApproach(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgFishingFishFloatTouch(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgFishingItemGet(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgFishingLineTouch(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgFishingStart(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgFishingUpImmediately(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgFishingUpImmediatelyPrepare(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgFishingWait(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgFrogHackTrample(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgGamaneBullet(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgGamaneBulletThrough(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgGamaneBulletForCoinFlower(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgGemyAim(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgGhostCancel(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgGhostPlay(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgGhostRecordEnd(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgGhostRecordStart(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgGhostRecordStartOk(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgGhostReverse(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgGhostStop(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgGiantWanderBossAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgGiantWanderBossBulletAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgGiantWanderBossBulletPush(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgGoldHammerAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgGrowFlowerSeedDisablePush(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgGrowFlowerSeedNear(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgGrowPlantPush(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgGrowerAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgGrowerWallAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgGunetterAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgGunetterBodyTouch(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgGunetterPush(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHackAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHackAttackKick(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHackAttackMapObj(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHackBrosContact(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHackDeathAreaSelfCheck(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHackDemoEnd(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHackDemoStart(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHackInvalidEscape(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHackInvalidEscapeNoReaction(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHackMarioCheckpointFlagWarp(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHackMarioDead(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHackMarioDemo(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHackMarioInWater(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHackMoveRockForestPush(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHackSelfCeilingCheckMiss(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHackSyncDamageVisibility(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHackUpperPunch(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHackObjUpperPunch(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHammerAttackDown(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHammerAttackSide(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHammerAttackSideCollide(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHammerBrosHammerEnemyAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHammerBrosHammerHackAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHammerBrosHammerSearch(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHipDropTransformReverse(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHipDropTransformTransform(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHipDropTransformingUp(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHipDropTransformingDown(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHipDropTransformingFinish(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHitGrowFlowerPot(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHitGrowPlantPot(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHosuiAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHosuiAttackCollide(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHosuiAttackNoEffect(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHosuiAttackStrong(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHosuiTouch(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHosuiTrample(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHosuiTrampleReflect(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHosuiTrampleReflectHigh(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgIgnoreTouchTarget(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgIgnorePushMotorcycle(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgIcicleAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgIgnoreMirrorWarp(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgIgnoredByRunawayNpc(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgImplantGrowFlowerSeed(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgInitTouchTargetInfo(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgItemAmiiboKoopa(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgIsExistPukupuku(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgJangoAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgJangoRemoveCap(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKakkuKick(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKoopaBindStart(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKoopaCapPlayerFocusTarget(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKoopaCapPunchFinishL(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKoopaCapPunchFinishR(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKoopaCapPunchInvincibleL(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKoopaCapPunchInvincibleR(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKoopaCapPunchKnockBackL(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKoopaCapPunchKnockBackR(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKoopaCapPunchL(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKoopaCapPunchR(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKoopaCapSpinAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKoopaCatchKoopaCap(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKoopaDashPunchAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKoopaFire2D(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKoopaFireBallAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKoopaHackDamage(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKoopaHackPunch(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKoopaHackPunchCollide(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKoopaHackTrample(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKoopaInvalidHackPunchFaceToCollision(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKoopaRingBeamInvalidTouch(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKoopaTailAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKoopaTouchFloor(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKouraAttack2D(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKouraItemGet2D(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKuribo2DTouch(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKuriboCollisionDamage(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKuriboCollisionKill(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKuriboFlick(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKuriboGirlAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKuriboGirlLove(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKuriboTop(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKuriboTowerNum(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgLaunchBlow(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgLineDancerLink(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgLongPushSensorHit(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgLongPushBoxHit(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgMagnetBulletAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgMeganeAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgMeganeHackTrample(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgMofumofuBodyChainExplode(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgMofumofuBulletUnexplosion(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgMoonBasementAttackMeteor(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgMoonBasementBreakShockwaveMeteor(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgMoonBasementRockSyncClippingRegist(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgMoonBasementRockSyncClippingInvalidate(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgMoonBasementRockSyncClippingValidate(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgMoonBasementRockThroughCollision(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgMorningStarWarpEnd(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgMorningStarWarpStart(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgMotorcycleAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgMotorcycleCollideParkingLot(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgMotorcycleDashAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgMotorcycleDashCollide(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCactusNeedleAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCactusNeedleAttackStrong(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgNoLimitTouchJump(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgNoticePlayerDamage(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgNpcScareByEnemy(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgVolleyballNpcScareByEnemy(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgObjSnapForce(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPackunEatCancel(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPackunEatEnd(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPackunEatStart(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPackunEatStartFollow(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPaint(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPaintTexture(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCheckPaintClear(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCheckPaintAlpha(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPartyPopperSoundAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPechoSpot(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerBallToss(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerCarryCameraSubjectiveStart(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerCarryCameraSubjectiveEnd(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerCarryShineGetStart(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerCarryShineGetEnd(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerCapCatch(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerCapHipDrop(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerCapPush(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerCapRecovery(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerCapTouchJump(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerCapTrample(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerCoinDashGet(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerEyePriorityTarget(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerDisregardHomingAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerDisregardTargetMarker(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerEquipKoopaCap(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerFireBallAttack2D(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerFireBallAttack3D(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerHipDropDemoTrigger(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerHipDropHipDropSwitch(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerItemGet2D(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerJumpTakeOffFloor(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerObjectWallHit(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerObjLeapFrog(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerPenguinAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerPenguinAttackReflect(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerPoleClimbKeep(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerPoleClimbReaction(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerRabbitGet(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerRollingObjHit(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerRollingWallHitDown(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerRollingWallHitMove(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerStartGrabCeil(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerStartWallJump(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerEndGrabCeil(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerSwordAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerTouchFloorJumpCode(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerTrample2D(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerUpperPunch2D(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerObjUpperPunch2D(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPropellerAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPukupukuDash(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPukupukuKiss(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPukupukuRollingAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPunchMachinePunchHook(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPunchMachinePunchStraight(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPunchMachinePunchUpper(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPush2D(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPushToFish(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPushToMotorcycle(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPushToPlayer(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgRadishAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgRadishReflect(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgRaceStart(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgRaceStop(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgRaceWait(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgRequestChangeFireFlower(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgRequestChangeKinokoSuper(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgRequestPlayerJumpBreakFloor(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgRequestPlayerJump(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgRequestPlayerTrampleJump(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgRequestPlayerSpinJump(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgRequestSphinxJump(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgRideOnEnd(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgRideOnRelease(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgRideOnStart(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgRocketFlowerExtension(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgSandSharkAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgSeedAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgSeedAttackBig(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgSeedAttackHold(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgSeedItemGet(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgSeedReflect(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgSeedTouch(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgSenobiCancelStretch(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgSenobiPunchBlockTransparent(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgSenobiPartsMove(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgSenobiTrample(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgShibakenApproach(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgShibakenKick(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgSkaterAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgSpherePush(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgSphinxJumpAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgSphinxQuizRouteKill(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgSphinxRideAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgSphinxRideAttackReflect(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgSphinxRideAttackTouchThrough(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgSphinxRideAttackTouch(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgStampTo2D(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgStartHack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgStartInSaucePan(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgStatueDrop(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgStatueTrampleReflect(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgStatuePush(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgStatueSnap(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgSunshineAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTankBullet(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTankBulletNoReaction(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTankExplosion(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTankHackTrample(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTankKickHack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTankKickEnemy(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTankLookOn(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTestPunch(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTestPunchStrong(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTimerAthleticDemoStart(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTouchDoorDrumn(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTouchFireDrum2D(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTrashBoxIn(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTRexAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTRexAttackCollideAll(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTRexAttackCollideBody(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTRexAttackCollideHead(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTRexDashAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTRexScrollPartsBreakWith(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTsukkunForceCancelCollide(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTsukkunHoldCollide(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTsukkunThroughCollide(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTsukkunThrustAll(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTsukkunThrust(const al::SensorMsg*, bool*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTsukkunThrustCollide(const al::SensorMsg*, bool*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTsukkunNoTrace(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTsukkunThrustHole(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgUtsuboAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgWanderBossCameraRange(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgWanwanEnemyAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgWanwanBlockAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgWanwanHoleIn(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgWaterRoadIn(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgWaterRoadNear(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgWanwanPush(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgWanwanReboundAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgWeaponItemGet(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgWhipAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgWhipBind(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgWhipHold(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgWhipThrow(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgYokinBallAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgYoshiDirectEat(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgYoshiTongueAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgYoshiTongueEatBind(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgYoshiTongueEatBindCancel(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgYoshiTongueEatBindFinish(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgYoshiTongueEatHomingTarget(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgYukimaruPush(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKillerAttackNoExplode(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKillerMagnumAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKillerMagnumHackAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgGabuzouAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgStackerRollingAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgStackerCapBoostAttack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgIgnoreIgnitionBomb(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgExplosionReflectBomb(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgGolemStampPress(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

void rs::setMsgYoshiTongueEatBindRadiusAndOffset(const al::SensorMsg*, f32, f32)

#include <Util/SensorMsgFunction.h>

void rs::setMsgYoshiTongueEatBindScale(const al::SensorMsg*, f32)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTsukkunThrustSpin(const al::SensorMsg*, bool*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTsukkunThrustReflect(const al::SensorMsg*, bool*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTsukkunThrustHitReflectCollide(const al::SensorMsg*, bool*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTsukkunThrustReflectCollide(const al::SensorMsg*, bool*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgSwitchOnWithSaveRequest(const al::SensorMsg*, SaveObjInfo**)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgNpcCapReactionAll(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHackNpcCapReactionAll(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::checkMsgNpcTrampleReactionAll(const al::SensorMsg*, const al::HitSensor*, const al::HitSensor*, bool)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerAndCapObjHipDropReflectAll(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKoopaCapPunchAll(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKoopaCapPunchInvincibleAll(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKoopaCapPunchFinishAll(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgItemGet(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgItemGetByWeapon(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgItemGet2D(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBlockUpperPunch2D(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgItemGetAll(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgShineGet(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgShineGet2D(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgShineReaction(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKillByShineGet(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKillByHomeDemo(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgEndHomeDemo(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBreakBySword(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPressDown(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerAndCapObjHipDropAll(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgAttackDirect(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBlowDown(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTrampleReflectAll(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgThrowObjHit(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgThrowObjHitReflect(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerAndCapHipDropAll(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgUpperPunchAll(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBlockUpperPunch2D(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBlockReaction2D(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBlockReaction3D(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBlockReactionAll(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBreakFrailBox(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgDamageFrailBox(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgChorobonReaction(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBreakSignBoard(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBreakCollapseSandHill(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

void rs::calcBlowDownDir(sead::Vector3f*, const al::SensorMsg*, al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetTsukkunThrustDir(sead::Vector3f*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerDamage(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerDamage2D(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerDamageBlowDown(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerJumpRequestAll(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::trySendMsgHackPunchToCeil(al::LiveActor*, al::HitSensor*)

#include <Util/SensorMsgFunction.h>

bool rs::trySendMsgHackPunchToSensor(al::LiveActor*, al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgDashPanel(const al::SensorMsg*, s32*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgNetworkShootingShot(const al::SensorMsg*, s32)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgNetworkShootingChargeShot(const al::SensorMsg*, s32)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgRaceReturnToCourse(const al::SensorMsg*, sead::Vector3f*, sead::Vector3f*)

#include <Util/SensorMsgFunction.h>

bool rs::isFallingTargetMoonBasementRock(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetTestPunchInfo(sead::Vector3f*, s32*, const al::SensorMsg*, s32)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetTestPunchTeamId(s32*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetPunchGuard(s32*, const al::SensorMsg*, s32)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetTsukkunThrustInfo(sead::Vector3f*, s32*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetTsukkunThrustReflectDir(sead::Vector3f*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetTsukkunThrustHole(sead::Vector3f*, sead::Vector3f*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetRequestPlayerJumpInfo(f32*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetRequestPlayerTrampleJumpInfo(f32*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetRequestPlayerSpinJumpInfo(f32*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetRequestSphinxJumpInfo(f32*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetTouchTargetInfo(TouchTargetInfo**, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetTouchTargetInfoCollisionTouchPos(sead::Vector3f*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryInitTouchTargetInfoBySensorOffset(const al::SensorMsg*, const al::HitSensor*, const sead::Vector3f&, const sead::Vector3f&)

#include <Util/SensorMsgFunction.h>

bool rs::tryInitTouchTargetInfoByConnector(const al::SensorMsg*, const al::MtxConnector*, const sead::Vector3f&, const sead::Vector3f&, bool)

#include <Util/SensorMsgFunction.h>

bool rs::tryCalcCollisionImpulse(sead::Vector3f*, f32, const sead::Vector3f&, f32, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryInitWhipTarget(const al::SensorMsg*, al::HitSensor*, const sead::Vector3f*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetWhipThrowDir(sead::Vector3f*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryMagnetPower(bool*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryMagnetBulletAttack(f32*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTrampolineCrackJump(f32*, f32*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

void rs::requestHitReactionToAttacker(const al::SensorMsg*, const al::HitSensor*, const al::HitSensor*)

#include <Util/SensorMsgFunction.h>

void rs::requestHitReactionToAttacker(const al::SensorMsg*, const al::HitSensor*, const sead::Vector3f&)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetCapTouchWallHitPos(sead::Vector3f*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetCapTouchWallNormal(sead::Vector3f*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isCapRethrowReturnOnly(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetCapRethrowPos(sead::Vector3f*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetCapRethrowFront(sead::Vector3f*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetCapRethrowUp(sead::Vector3f*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetHackBlowJump(sead::Vector3f*, f32*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetGolemStampPushV(f32*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetGolemStampPushH(f32*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetRequestPlayerWaitAnim(const char**, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetCapChangeGiant(f32*, s32*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetByugoBlowForce(sead::Vector3f*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetObjSnapForce(sead::Vector3f*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

void rs::getPackunEatCancelPosAndFront(sead::Vector3f*, sead::Vector3f*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetPackunEatEndPos(sead::Vector3f*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetPackunEatEndDir(sead::Vector3f*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetPackunEatStartFollowPos(const sead::Vector3f**, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetFireBlowerAttackPos(sead::Vector3f*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetFireBlowerAttackDir(sead::Vector3f*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetFireBlowerAttackRadius(f32*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetPaintColor(sead::Color4u8*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetPaintSize(f32*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetPaintDrawType(s32*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetPaintTextureSize(f32*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetPaintTextureRotation(f32*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetPaintTextureDrawType(s32*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetCheckPaintClearColor(sead::Color4u8*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetCheckPaintClearPos(sead::Vector3f*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetCheckPaintClearDrawType(s32*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetCheckPaintAlphaPos(sead::Vector3f*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetSenobiPartsMoveDistance(f32*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetSenobiPartsCollidedNormal(sead::Vector3f*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetStampTo2DForce(sead::Vector3f*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetGhostStartOkObjId(sead::BufferedSafeStringBase<char>*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetAirExplosionForce(sead::Vector3f*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGotogotonOn(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGotogotonGetJumpPath(al::HitSensor* source, al::HitSensor* target, al::ParabolicPath*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGotogotonGoalExist(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgGotogotonGoalMatch(al::HitSensor* source, al::HitSensor* target, const GotogotonMark*)

#include <Util/SensorMsgFunction.h>

bool rs::isMatchGotogotonGoal(const al::SensorMsg*, const GotogotonMark*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgGotogotonOn(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgGotogotonGoalExist(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBossMagmaBreathForce(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBossMagmaCatchPlayer(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBossMagmaReleasePlayer(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBossMagmaDeadDemoStart(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBossMagmaDeadDemoEnd(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBossMagmaResetPos(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgBossMagmaQueryToBubble(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBossMagmaCatchPlayer(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBossMagmaReleasePlayer(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBossMagmaDeadDemoStart(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBossMagmaDeadDemoEnd(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetBossMagmaDeadDemoEndTargetPos(const al::SensorMsg*, sead::Vector3f*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetBossMagmaBreathForce(const al::SensorMsg*, sead::Vector3f*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetBossMagmaResetPos(const al::SensorMsg*, sead::Vector3f*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgBossMagmaQueryToBubble(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

s32 rs::getMofumofuBodyChainExplodeDelayStep(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgMofumofuReflectAll(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

void rs::calcFishingUpJugemDir(sead::Vector3f*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

const sead::Vector3f& rs::getFishingUpFloatPos(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

const char* rs::tryGetFishingUpFloatMaterialCode(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

al::HitSensor* rs::getFishingHookSensor(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgCheckFishingTarget(al::HitSensor* source, al::HitSensor* target, const FishingFish*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgCheckFishingTarget(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

const FishingFish* rs::getCheckFishingTarget(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

const sead::Vector3f& rs::getGunetterPushCenter(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

f32 rs::getGunetterPushRadius(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

u32 rs::getNumKuriboTowerOn(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgPlayerLookAtPosition(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

void rs::setMsgPlayerLookAtPosition(const al::SensorMsg*, const sead::Vector3f&)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTargetMarkerPosition(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

void rs::setMsgTargetMarkerPosition(const al::SensorMsg*, const sead::Vector3f&)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgSandGeyserRaise(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryGetSandGeyserRaise(const al::SensorMsg*, f32*, f32*)

#include <Util/SensorMsgFunction.h>

void rs::tryTreasureBoxPlayerTrampleJump(al::LiveActor*, al::HitSensor* source, al::HitSensor* target, f32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPushToPlayerAndKillVelocityToTarget(al::LiveActor*, al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgPushToPlayerAndKillVelocityToTargetH(al::LiveActor*, al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::tryReceivePushAndAddVelocity(al::LiveActor*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::tryReceiveMsgPushToPlayerAndAddVelocity(al::LiveActor*, const al::SensorMsg*, const al::HitSensor*, const al::HitSensor*, f32)

#include <Util/SensorMsgFunction.h>

bool rs::tryReceiveMsgPushToPlayerAndAddVelocityH(al::LiveActor*, const al::SensorMsg*, const al::HitSensor*, const al::HitSensor*, f32)

#include <Util/SensorMsgFunction.h>

bool rs::tryReceiveMsgPushToPlayerAndCalcPushTrans(sead::Vector3f*, const al::SensorMsg*, const al::LiveActor*, const al::HitSensor*, const al::HitSensor*, f32)

#include <Util/SensorMsgFunction.h>

bool rs::tryReceiveMsgPushToHackerAndCalcPushTrans(sead::Vector3f*, const al::SensorMsg*, const al::LiveActor*, const al::HitSensor*, const al::HitSensor*, f32, bool)

#include <Util/SensorMsgFunction.h>

bool rs::tryReceiveMsgPushToYoshiNpcAndCalcPushTrans(sead::Vector3f*, const al::SensorMsg*, const al::LiveActor*, const al::HitSensor*, const al::HitSensor*, f32)

#include <Util/SensorMsgFunction.h>

bool rs::tryReceiveMsgPushToCapAndCalcPushTrans(sead::Vector3f*, const al::SensorMsg*, const al::LiveActor*, const al::HitSensor*, const al::HitSensor*, f32)

#include <Util/SensorMsgFunction.h>

bool rs::tryReceiveMsgPushToGrowPlantAndCalcPushTrans(sead::Vector3f*, const al::SensorMsg*, const al::LiveActor*, const al::HitSensor*, const al::HitSensor*, f32)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgInitCapTarget(al::HitSensor* source, al::HitSensor* target, const CapTargetInfo**)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgInitCapTarget(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

void rs::setCapTargetInfo(const al::SensorMsg*, const CapTargetInfo*)

#include <Util/SensorMsgFunction.h>

bool rs::tryReceiveMsgInitCapTargetAndSetCapTargetInfo(const al::SensorMsg*, const CapTargetInfo*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgTransferHack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgRequestTransferHack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgInitHack(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgEndHack(al::HitSensor* source, al::HitSensor* target, const HackEndParam*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgTransferHack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgRequestTransferHack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgInitHack(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgEndHack(const HackEndParam**, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgHackDirectStageInit(IUsePlayerHack**, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKillByBossBattleDemo(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKillByHackFirstDemo(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKillByMoonRockDemo(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::sendMsgNpcScareByEnemy(al::HitSensor* source, al::HitSensor* target, s32)

#include <Util/SensorMsgFunction.h>

bool rs::tryReceiveMsgNpcScareByEnemyIgnoreTargetHack(const al::SensorMsg*, const CapTargetInfo*)

#include <Util/SensorMsgFunction.h>

bool rs::tryIncrementComboCount(s32*, const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

ComboCounter* rs::tryGetMsgComboCount(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

ComboCounter* rs::getMsgComboCount(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isRideOn(const al::HitSensor*, const al::HitSensor*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgKillBySwitchTimer(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isVisibleChameleon(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

bool rs::isMsgRequestPlayerStainWet(const al::SensorMsg*, s32*)

#include <Util/SensorMsgFunction.h>

s32 rs::tryGetKuriboTowerNum(al::HitSensor* source, al::HitSensor* target)

#include <Util/SensorMsgFunction.h>

void rs::setKuriboTowerNum(const al::SensorMsg*, s32)

#include <Util/SensorMsgFunction.h>

const sead::Vector3f& rs::getSpherePushCenter(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

f32 rs::getSpherePushRadius(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

DigPoint* rs::getSmellDigPoint(const al::SensorMsg*)

#include <Util/SensorMsgFunction.h>

void rs::convertCsecTo(s32* minutes, s32* seconds, s32* csec, s32 time)

#include <Util/SequentialUtil.h>

f32 rs::setShadowDropLength(al::LiveActor*, const al::ActorInitInfo&, const char*)

#include <Util/ShadowUtil.h>

f32 rs::calcShadowDropClippingCenter(sead::Vector3f*, const al::LiveActor*, f32, f32)

#include <Util/ShadowUtil.h>

void rs::setShadowDropOffset(al::LiveActor*, const char*, f32)

#include <Util/ShadowUtil.h>

WaterSurfaceShadow* rs::tryCreateWaterSurfaceShadow(const al::ActorInitInfo&, const char*)

#include <Util/ShadowUtil.h>

WaterSurfaceShadow* rs::tryCreateWaterSurfaceCoinShadow(const al::ActorInitInfo&)

#include <Util/ShadowUtil.h>

void rs::tryUpdateWaterSurfaceCoinShadow(WaterSurfaceShadow*, al::LiveActor*, f32)

#include <Util/ShadowUtil.h>

void rs::initHackShadow(al::LiveActor*)

#include <Util/ShadowUtil.h>

void rs::setupHackShadow(al::LiveActor*)

#include <Util/ShadowUtil.h>

void rs::endHackShadow(al::LiveActor*)

#include <Util/ShadowUtil.h>

bool rs::isModeE3Rom()

#include <Util/SpecialBuildUtil.h>

bool rs::isModeE3MovieRom()

#include <Util/SpecialBuildUtil.h>

bool rs::isModeE3LiveRom()

#include <Util/SpecialBuildUtil.h>

bool rs::isModeDiverRom()

#include <Util/SpecialBuildUtil.h>

bool rs::isModeJungleGymRom()

#include <Util/SpecialBuildUtil.h>

bool rs::isModeDiverOrJungleGymRom()

#include <Util/SpecialBuildUtil.h>

bool rs::isModeMovieRom()

#include <Util/SpecialBuildUtil.h>

bool rs::isModeEpdMovieRom()

#include <Util/SpecialBuildUtil.h>

void rs::changeSeparatePlayMode(al::Scene*, bool)

#include <Util/StageInputFunction.h>

void rs::setSeparatePlayMode(al::Scene*, bool)

#include <Util/StageInputFunction.h>

bool rs::isTriggerUiDecide(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isTriggerUiDecide(const GameDataHolder*)

#include <Util/StageInputFunction.h>

bool rs::isTriggerUiCancel(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isTriggerUiSelect(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isTriggerUiPause(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isTriggerUiLeft(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isTriggerUiRight(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isTriggerUiUp(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isTriggerUiDown(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isTriggerUiR(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isTriggerUiL(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isTriggerUiZR(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isTriggerUiZL(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isTriggerUiX(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isTriggerUiY(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isTriggerUiAnyABXY(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isRepeatUiUp(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isRepeatUiDown(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isRepeatUiRight(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isRepeatUiLeft(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isHoldUiDecide(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isHoldUiCancel(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isHoldUiSelect(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isHoldUiL(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isHoldUiR(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isHoldUiY(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isHoldUiUp(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isHoldUiDown(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isHoldUiLeft(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isHoldUiRight(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isHoldSeparatePlayStart1P(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isHoldSeparatePlayStart2P(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isTriggerMapOpen(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isHoldSeparatePlayEnd(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

const sead::Vector2f& rs::getUiLeftStick(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

const sead::Vector2f& rs::getUiRightStick(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isTriggerMapClose(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isTriggerCollectionListOpenInMap(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isTriggerCollectionListCloseInMap(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isTriggerAppearSkipGuide(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isTriggerUiRacePause(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isTriggerSnapShotMode(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isTriggerAmiiboMode(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isHoldAmiiboMode(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isTriggerToggleSnapShotModeLayout(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isTriggerAppearSnapShotLayout(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isTriggerIncrementPostProcessingFilterPreset(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

bool rs::isTriggerDecrementPostProcessingFilterPreset(const al::IUseSceneObjHolder*)

#include <Util/StageInputFunction.h>

void rs::recordGamePadPlayStyleInfo(GamePadPlayStyleInfo*, const al::LiveActor*)

#include <Util/StageInputFunction.h>

void rs::recordGamePadPlayStyleInfo(GamePadPlayStyleInfo*, const al::LayoutActor*)

#include <Util/StageInputFunction.h>

bool rs::tryUpdateGamePadPlayStyleInfo(GamePadPlayStyleInfo*, const al::LiveActor*)

#include <Util/StageInputFunction.h>

bool rs::tryUpdateGamePadPlayStyleInfo(GamePadPlayStyleInfo*, const al::LayoutActor*)

#include <Util/StageInputFunction.h>

const char16* rs::searchNpcMessage(const al::ActorInitInfo&, const al::LayoutActor*)

#include <Util/StageLayoutFunction.h>

void rs::makeActorMessageLabel(sead::BufferedSafeString*, const al::ActorInitInfo&, const char*)

#include <Util/StageLayoutFunction.h>

void rs::makeMessageLabel(sead::BufferedSafeString*, const al::PlacementInfo&, const char*)

#include <Util/StageLayoutFunction.h>

void rs::makeMessageLabel(sead::BufferedSafeString*, const al::PlacementId*, const char*)

#include <Util/StageLayoutFunction.h>

void rs::setPaneStageMessageActorLabel(al::LayoutActor*, const char*, const al::ActorInitInfo&, const char*)

#include <Util/StageLayoutFunction.h>

bool rs::trySetPaneStageMessageIfExist(al::LayoutActor*, const char*, const char*, const char*)

#include <Util/StageLayoutFunction.h>

const char* rs::getPlacementStageName(GameDataHolderAccessor, const al::ActorInitInfo&)

#include <Util/StageLayoutFunction.h>

const char16* rs::getStageMessageActorLabel(al::LayoutActor*, const al::ActorInitInfo&, const char*)

#include <Util/StageLayoutFunction.h>

bool rs::isExistLabelInSystemMessageWithFileName(const al::IUseMessageSystem*, const char*, const char*)

#include <Util/StageLayoutFunction.h>

bool rs::isExistLabelInStageMessageWithFileName(const al::IUseMessageSystem*, const char*, const char*)

#include <Util/StageLayoutFunction.h>

bool rs::trySetPaneSystemMessageIfExist(al::LayoutActor*, const char*, const char*, const char*)

#include <Util/StageLayoutFunction.h>

bool rs::trySetPaneStringCheckpos32Name(al::LayoutActor*, const char*, s32, const char*)

#include <Util/StageLayoutFunction.h>

const char* rs::getCheckpointLabelPrefix()

#include <Util/StageLayoutFunction.h>

void rs::setPaneStringWorldNameForWorldMap(al::LayoutActor*, const char*, s32)

#include <Util/StageLayoutFunction.h>

void rs::setPaneStringWorldNameForWorldMapWithoutRuby(al::LayoutActor*, const char*, s32)

#include <Util/StageLayoutFunction.h>

void rs::setRaceRecordMessage(al::LayoutActor*, const char*, s32)

#include <Util/StageLayoutFunction.h>

void rs::setRaceRecordMessageCsec(al::LayoutActor*, const char*, s32)

#include <Util/StageLayoutFunction.h>

void rs::replaceRaceRecordMessageCsec(al::LayoutActor*, const char*, s32, const char16*, const char*)

#include <Util/StageLayoutFunction.h>

void rs::setRaceNoRecordMessage(al::LayoutActor*, const char*)

#include <Util/StageLayoutFunction.h>

void rs::setMiniGameNoCountMessage(al::LayoutActor*, const char*)

#include <Util/StageLayoutFunction.h>

const char16* rs::getWorldShinePictureFont(const al::LayoutActor*, s32, bool)

#include <Util/StageLayoutFunction.h>

const char16* rs::getNullShinePictureFont(const al::LayoutActor*)

#include <Util/StageLayoutFunction.h>

const char16* rs::getWorldCoinCollectPictureFont(const al::LayoutActor*, s32)

#include <Util/StageLayoutFunction.h>

const char16* rs::getWorldCoinCollectPictureFont(const al::LayoutActor*)

#include <Util/StageLayoutFunction.h>

const char* rs::getPlacementStageName(GameDataHolderAccessor, const al::PlacementInfo&)

#include <Util/StageLayoutFunction.h>

const char16* rs::getCollectBgmMessage(const al::IUseMessageSystem*, const CollectBgm*)

#include <Util/StageLayoutFunction.h>

void rs::setPaneCurrentCoinNum(al::LayoutActor*)

#include <Util/StageLayoutFunction.h>

bool rs::tryGetMapMainScenarioLabel(sead::BufferedSafeString*, sead::BufferedSafeString*, bool*, const al::IUseSceneObjHolder*)

#include <Util/StageLayoutFunction.h>

bool rs::isOnSwitchLinkSave(const al::LiveActor* actor, const al::ActorInitInfo& actorInitInfo)

#include <Util/SwitchUtil.h>

bool rs::isSaveSwitch(const al::ActorInitInfo& actorInitInfo)

#include <Util/SwitchUtil.h>

void rs::registerLayoutTextureRenderObj(al::IUseSceneObjHolder* user, al::LayoutTextureRenderObj* renderObj)

#include <Util/TextureUtil.h>

bool rs::checkTimeReverseAndRestore(u64*, u64)

#include <Util/TimeUtil.h>

bool rs::isSensorTypeYoshiEnableSendPush(const al::HitSensor* sensor)

#include <Util/YoshiUtil.h>

bool rs::isSensorTypeYoshiMsgReceivable(const al::HitSensor* sensor)

#include <Util/YoshiUtil.h>

bool rs::isInPuddleHeight(const al::WaterSurfaceFinder* surfaceFinder, const PlayerConst* playerConst)

#include <Util/YoshiUtil.h>

bool rs::tryCalcTonguePullPose(sead::Quatf* pose, const al::LiveActor* actor, const YoshiTongue* yoshiTongue)

#include <Util/YoshiUtil.h>

bool rs::findClingGroundPos(sead::Vector3f* pos, const al::LiveActor* actor, const sead::Vector3f&, f32)

#include <Util/YoshiUtil.h>

Variable documentation

const sead::Vector3f rs::sItemOffset

#include <Util/ItemUtil.cpp>