diff --git a/Makefile b/Makefile index e6864ac..8c08aef 100644 --- a/Makefile +++ b/Makefile @@ -7,6 +7,8 @@ S2VER ?= 100 S2VERSTR ?= 1.0.0 S2ROMTYPE ?= US IP ?= 0.0.0.0 # Put Switch IP Here (for make send) +USER ?= user # Put username here (for make send) +PASS ?= name # put password here (for make send) PROJNAME ?= StarlightBase @@ -30,7 +32,7 @@ starlight_patch_$(S2VER)/*.ips: patches/*.slpatch patches/configs/$(S2VER).confi # NOTE: Make sure you configure sendPatch.py to use your login for ftp servers! send: all - python3.8 scripts/sendPatch.py $(IP) $(PROJNAME) + python3.8 scripts/sendPatch.py $(IP) $(PROJNAME) $(USER) $(PASS) clean: $(MAKE) clean -f MakefileNSO diff --git a/README.md b/README.md index 76b8f45..e6d9715 100644 --- a/README.md +++ b/README.md @@ -14,6 +14,18 @@ The changes in this fork are made incrementally & intentionally, with the goal o - Python 3 - The [Keystone-Engine](https://www.keystone-engine.org/) Python Module +## Configuration and Setup + +Before Building, you should make sure that the default things for the project is properly setup. + +For the TCP Logger, you can define `GLOBALDEBUGIP` to set the IP address used for connecting the socket to a server hosted on your local machine. + +In the makefile, you can set `IP`, `USER`, and `PASS` to their respective values in order to automatically send builds to an FTP server hosted on a modded switch. Then, whenever you run `make send` you'll build the project and immediately send to the switch. + +Creating a custom actor is straight forward thankfully, and there is an example actor in this repository if you wish to start from one already proven working. To add more custom actors, firs you'll need to create the custom actors header and c++ files in their respective folders. Then, create a class that extends `al::LiveActor` and implement the virtual functions used in the example actor. You can then define nerves by using the `NERVE_IMPL` and `NERVE_HEADER` macros used in the [OdysseyDecomp](https://github.com/MonsterDruide1/OdysseyDecomp) project, which I included here for easy nerve defines. Then, after creating your actor, navigate to `al/factory/ActorFactoryEntries100.h` and add in the name of your class, as well as its creation function (do this by simply using al::createCustomActor<Type> in the second parameter for factory entries) to the static table of actor creators. + +Once you've handled most of the code for the custom actor, you can either copy an existing object archive from SMO and edit it to your liking, or create an entirely new archive, so long as the archive contains the minimum Init bymls required for an actor (most of the time its InitModel.byml, InitPose.byml, InitClipping.byml, InitExecutor.byml, and InitMaterialLight.byml), and a BFRES model if your actor needs it. Once done, save the archive, and add your custom actor to a stage you wish to have the actor in. From there everything should work and you'll have a custom actor working in Odyssey! + ## Building Build has only been tested on WSL2 running Ubuntu 20.04.1. diff --git a/include/al/factory/ActorFactoryEntries100.h b/include/al/factory/ActorFactoryEntries100.h index 6b93dc7..3535940 100644 --- a/include/al/factory/ActorFactoryEntries100.h +++ b/include/al/factory/ActorFactoryEntries100.h @@ -69,7 +69,9 @@ namespace al } // namespace al static al::FactoryEntry actorEntries[] = { - {"DeathBlockBrick", &al::createCustomActor}, + // CUSTOM ACTOR ENTRIES HERE + {"BlockShine", &al::createCustomActor}, + // VANILLA ACTOR ENTRIES {"AchievementNpc", &al::createActorFunction}, {"AirBubble", &al::createActorFunction}, {"AirBubbleGenerator", &al::createActorFunction}, diff --git a/include/al/sensor/IsMsg.h b/include/al/sensor/IsMsg.h new file mode 100644 index 0000000..b96cca9 --- /dev/null +++ b/include/al/sensor/IsMsg.h @@ -0,0 +1,722 @@ +#pragma once + +#include "sead/math/seadVector.h" + +#include "al/LiveActor/LiveActor.h" +#include "game/Interfaces/IUsePlayerCollision.h" +#include "game/Interfaces/IUsePlayerHack.h" + +#include "HitSensor.h" +#include "SensorMsg.h" + +struct SaveObjInfo; +struct HackEndParam; + +namespace rs +{ + bool isMsgBreakBySword(al::SensorMsg const *); + bool isMsgStatueDrop(al::SensorMsg const *); + bool isMsgHackerDamageAndCancel(al::SensorMsg const *); + bool isMsgEnableMapCheckPointWarpCollidedGround(al::SensorMsg const *, al::LiveActor const *); + bool isMsgEnableMapCheckPointWarpCollidedGround(al::SensorMsg const *, IUsePlayerCollision const *); + bool isMsgAckCheckpoint(al::SensorMsg const *); + bool isMsgAckGetShine(al::SensorMsg const *); + bool isMsgAckLifeUp(al::SensorMsg const *); + bool isMsgAckLifeMaxUp(al::SensorMsg const *); + bool isMsgAskRailCollision(al::SensorMsg const *); + bool isMsgAttachCactusNeedle(al::SensorMsg const *); + bool isMsgAirExplosion(al::SensorMsg const *); + bool isMsgBelowObjBroken(al::SensorMsg const *); + bool isMsgBindCollidedGround(al::SensorMsg const *); + bool isMsgBindKeepDemoStart(al::SensorMsg const *); + bool isMsgBindKeepDemoExecute(al::SensorMsg const *); + bool isMsgBindKeepDemoEnd(al::SensorMsg const *); + bool isMsgBindRecoveryLife(al::SensorMsg const *); + bool isMsgBirdFlyAway(al::SensorMsg const *); + bool isMsgBlowObjAttack(al::SensorMsg const *); + bool isMsgMayorItemCollide(al::SensorMsg const *); + bool isMsgMayorItemReflect(al::SensorMsg const *); + bool isMsgBlowObjAttackReflect(al::SensorMsg const *); + bool isMsgBossKnuckleCounter(al::SensorMsg const *); + bool isMsgBossKnuckleFallAttack(al::SensorMsg const *); + bool isMsgBossKnuckleHackAttack(al::SensorMsg const *); + bool isMsgBossKnuckleIceConflict(al::SensorMsg const *); + bool isMsgBossKnuckleIceFallToMummy(al::SensorMsg const *); + bool isMsgBossKnuckleKillerAttack(al::SensorMsg const *); + bool isMsgBreakPartsBreak(al::SensorMsg const *); + bool isMsgBreedaSlap(al::SensorMsg const *); + bool isMsgBreedaPush(al::SensorMsg const *); + bool isMsgBubbleAttack(al::SensorMsg const *); + bool isMsgBubbleAttackToPecho(al::SensorMsg const *); + bool isMsgBubbleLauncherStart(al::SensorMsg const *); + bool isMsgBubbleReflectH(al::SensorMsg const *); + bool isMsgBubbleReflectV(al::SensorMsg const *); + bool isMsgBubbleWallTouch(al::SensorMsg const *); + bool isMsgBubbleGroundTouchTrigger(al::SensorMsg const *); + bool isMsgBullAttack(al::SensorMsg const *); + bool isMsgBullHackAttack(al::SensorMsg const *); + bool isMsgBullEnemyAttack(al::SensorMsg const *); + bool isMsgByugoBlow(al::SensorMsg const *); + bool isMsgCameraAngleElevationResetFast(al::SensorMsg const *); + bool isMsgCancelHack(al::SensorMsg const *); + bool isMsgCancelHackArea(al::SensorMsg const *); + bool isMsgCancelHackByDokan(al::SensorMsg const *); + bool isMsgCapAttack(al::SensorMsg const *); + bool isMsgCapAttackCollide(al::SensorMsg const *); + bool isMsgCapAttackRailMove(al::SensorMsg const *); + bool isMsgCapAttackStayRolling(al::SensorMsg const *); + bool isMsgCapAttackStayRollingCollide(al::SensorMsg const *); + bool isMsgCapBeamerBeam(al::SensorMsg const *); + bool isMsgCapCancelLockOn(al::SensorMsg const *); + bool isMsgCapChangeGiant(al::SensorMsg const *); + bool isMsgCapEnableLockOn(al::SensorMsg const *); + bool isMsgCapStartLockOn(al::SensorMsg const *); + bool isMsgCapKeepLockOn(al::SensorMsg const *); + bool isMsgCapGiantAttack(al::SensorMsg const *); + bool isMsgCapHipDrop(al::SensorMsg const *); + bool isMsgCapObjHipDrop(al::SensorMsg const *); + bool isMsgCapObjHipDropReflect(al::SensorMsg const *); + bool isMsgCapIgnoreCancelLockOn(al::SensorMsg const *); + bool isMsgCapIgnoreCancelMissReaction(al::SensorMsg const *); + bool isMsgCapIgnoreCollisionCheck(al::SensorMsg const *); + bool isMsgCapItemGet(al::SensorMsg const *); + bool isMsgCapReflect(al::SensorMsg const *); + bool isMsgCapReflectCollide(al::SensorMsg const *); + bool isMsgCapRethrow(al::SensorMsg const *); + bool isMsgCapTouchWall(al::SensorMsg const *); + bool isMsgCapTrampolineAttack(al::SensorMsg const *); + bool isMsgCatchBombThrough(al::SensorMsg const *); + bool isMsgCheckCarObstacle(al::SensorMsg const *); + bool isMsgCheckIsCardboardBox(al::SensorMsg const *); + bool isMsgChorobonAttack(al::SensorMsg const *); + bool isMsgClearFire(al::SensorMsg const *); + bool isMsgCollectAnimalTouchCollide(al::SensorMsg const *); + bool isMsgCollisionImpulse(al::SensorMsg const *); + bool isMsgConductLightning(al::SensorMsg const *); + bool isMsgConfirmFrailBox(al::SensorMsg const *); + bool isMsgConfirmBrokenFrailBox(al::SensorMsg const *); + bool isMsgDamageBallAttack(al::SensorMsg const *); + bool isMsgDamageBallBodyAttack(al::SensorMsg const *); + bool isMsgDigPointSmell(al::SensorMsg const *); + bool isMsgDonsukeAttack(al::SensorMsg const *); + bool isMsgDonsukeGroundAttack(al::SensorMsg const *); + bool isMsgDonsukePush(al::SensorMsg const *); + bool isMsgDragonAttack(al::SensorMsg const *); + bool isMsgEatExplosion(al::SensorMsg const *); + bool isMsgElectricWireNoLimitDistance(al::SensorMsg const *); + bool isMsgEnableInSaucePan(al::SensorMsg const *); + bool isMsgEnableMapCheckPointWarp(al::SensorMsg const *); + bool isMsgEndInSaucePan(al::SensorMsg const *); + bool isMsgEnemyAttack2D(al::SensorMsg const *); + bool isMsgEnemyAttack3D(al::SensorMsg const *); + bool isMsgEnemyAttackDash(al::SensorMsg const *); + bool isMsgFireBrosFireBallCollide(al::SensorMsg const *); + bool isMsgFireDamageAll(al::SensorMsg const *); + bool isMsgHackAttackFire(al::SensorMsg const *); + bool isMsgFireSwitchFire(al::SensorMsg const *); + bool isMsgEnemyAttackFireCollision(al::SensorMsg const *); + bool isMsgEnemyAttackTRex(al::SensorMsg const *); + bool isMsgPoisonDamageAll(al::SensorMsg const *); + bool isMsgEnemyAttackPoison(al::SensorMsg const *); + bool isMsgHackAttackPoison(al::SensorMsg const *); + bool isMsgPaintAttackPoison(al::SensorMsg const *); + bool isMsgConfirmPaintObj(al::SensorMsg const *); + bool isMsgConfirmPaintObjForSeed(al::SensorMsg const *); + bool isMsgEnemyAttackStrong(al::SensorMsg const *); + bool isMsgEnemyKick(al::SensorMsg const *); + bool isMsgRabbitKick(al::SensorMsg const *); + bool isMsgEnemyObjBreak(al::SensorMsg const *); + bool isMsgFireBlowerAttack(al::SensorMsg const *); + bool isMsgFishingAttack(al::SensorMsg const *); + bool isMsgFishingCancel(al::SensorMsg const *); + bool isMsgFishingFishApproach(al::SensorMsg const *); + bool isMsgFishingFishFloatTouch(al::SensorMsg const *); + bool isMsgFishingItemGet(al::SensorMsg const *); + bool isMsgFishingLineTouch(al::SensorMsg const *); + bool isMsgFishingStart(al::SensorMsg const *); + bool isMsgFishingUpImmediately(al::SensorMsg const *); + bool isMsgFishingUpImmediatelyPrepare(al::SensorMsg const *); + bool isMsgFishingWait(al::SensorMsg const *); + bool isMsgFrogHackTrample(al::SensorMsg const *); + bool isMsgGamaneBullet(al::SensorMsg const *); + bool isMsgGamaneBulletThrough(al::SensorMsg const *); + bool isMsgGamaneBulletForCoinFlower(al::SensorMsg const *); + bool isMsgGemyAim(al::SensorMsg const *); + bool isMsgGhostCancel(al::SensorMsg const *); + bool isMsgGhostPlay(al::SensorMsg const *); + bool isMsgGhostRecordEnd(al::SensorMsg const *); + bool isMsgGhostRecordStart(al::SensorMsg const *); + bool isMsgGhostRecordStartOk(al::SensorMsg const *); + bool isMsgGhostReverse(al::SensorMsg const *); + bool isMsgGhostStop(al::SensorMsg const *); + bool isMsgGiantWanderBossAttack(al::SensorMsg const *); + bool isMsgGiantWanderBossBulletAttack(al::SensorMsg const *); + bool isMsgGiantWanderBossBulletPush(al::SensorMsg const *); + bool isMsgGoldHammerAttack(al::SensorMsg const *); + bool isMsgGrowFlowerSeedDisablePush(al::SensorMsg const *); + bool isMsgGrowFlowerSeedNear(al::SensorMsg const *); + bool isMsgGrowPlantPush(al::SensorMsg const *); + bool isMsgGrowerAttack(al::SensorMsg const *); + bool isMsgGrowerWallAttack(al::SensorMsg const *); + bool isMsgGunetterAttack(al::SensorMsg const *); + bool isMsgGunetterBodyTouch(al::SensorMsg const *); + bool isMsgGunetterPush(al::SensorMsg const *); + bool isMsgHackAttack(al::SensorMsg const *); + bool isMsgHackAttackKick(al::SensorMsg const *); + bool isMsgHackAttackMapObj(al::SensorMsg const *); + bool isMsgHackBrosContact(al::SensorMsg const *); + bool isMsgHackDeathAreaSelfCheck(al::SensorMsg const *); + bool isMsgHackDemoEnd(al::SensorMsg const *); + bool isMsgHackDemoStart(al::SensorMsg const *); + bool isMsgHackInvalidEscape(al::SensorMsg const *); + bool isMsgHackInvalidEscapeNoReaction(al::SensorMsg const *); + bool isMsgHackMarioCheckpointFlagWarp(al::SensorMsg const *); + bool isMsgHackMarioDead(al::SensorMsg const *); + bool isMsgHackMarioDemo(al::SensorMsg const *); + bool isMsgHackMarioInWater(al::SensorMsg const *); + bool isMsgHackMoveRockForestPush(al::SensorMsg const *); + bool isMsgHackSelfCeilingCheckMiss(al::SensorMsg const *); + bool isMsgHackSyncDamageVisibility(al::SensorMsg const *); + bool isMsgHackUpperPunch(al::SensorMsg const *); + bool isMsgHackObjUpperPunch(al::SensorMsg const *); + bool isMsgHammerAttackDown(al::SensorMsg const *); + bool isMsgHammerAttackSide(al::SensorMsg const *); + bool isMsgHammerAttackSideCollide(al::SensorMsg const *); + bool isMsgHammerBrosHammerEnemyAttack(al::SensorMsg const *); + bool isMsgHammerBrosHammerHackAttack(al::SensorMsg const *); + bool isMsgHammerBrosHammerSearch(al::SensorMsg const *); + bool isMsgHipDropTransformReverse(al::SensorMsg const *); + bool isMsgHipDropTransformTransform(al::SensorMsg const *); + bool isMsgHipDropTransformingUp(al::SensorMsg const *); + bool isMsgHipDropTransformingDown(al::SensorMsg const *); + bool isMsgHipDropTransformingFinish(al::SensorMsg const *); + bool isMsgHitGrowFlowerPot(al::SensorMsg const *); + bool isMsgHitGrowPlantPot(al::SensorMsg const *); + bool isMsgHosuiAttack(al::SensorMsg const *); + bool isMsgHosuiAttackCollide(al::SensorMsg const *); + bool isMsgHosuiAttackNoEffect(al::SensorMsg const *); + bool isMsgHosuiAttackStrong(al::SensorMsg const *); + bool isMsgHosuiTouch(al::SensorMsg const *); + bool isMsgHosuiTrample(al::SensorMsg const *); + bool isMsgHosuiTrampleReflect(al::SensorMsg const *); + bool isMsgHosuiTrampleReflectHigh(al::SensorMsg const *); + bool isMsgIgnoreTouchTarget(al::SensorMsg const *); + bool isMsgIgnorePushMotorcycle(al::SensorMsg const *); + bool isMsgIcicleAttack(al::SensorMsg const *); + bool isMsgIgnoreMirrorWarp(al::SensorMsg const *); + bool isMsgIgnoredByRunawayNpc(al::SensorMsg const *); + bool isMsgImplantGrowFlowerSeed(al::SensorMsg const *); + bool isMsgInitTouchTargetInfo(al::SensorMsg const *); + bool isMsgItemAmiiboKoopa(al::SensorMsg const *); + bool isMsgIsExistPukupuku(al::SensorMsg const *); + bool isMsgJangoAttack(al::SensorMsg const *); + bool isMsgJangoRemoveCap(al::SensorMsg const *); + bool isMsgKakkuKick(al::SensorMsg const *); + bool isMsgKoopaBindStart(al::SensorMsg const *); + bool isMsgKoopaCapPlayerFocusTarget(al::SensorMsg const *); + bool isMsgKoopaCapPunchFinishL(al::SensorMsg const *); + bool isMsgKoopaCapPunchFinishR(al::SensorMsg const *); + bool isMsgKoopaCapPunchInvincibleL(al::SensorMsg const *); + bool isMsgKoopaCapPunchInvincibleR(al::SensorMsg const *); + bool isMsgKoopaCapPunchKnockBackL(al::SensorMsg const *); + bool isMsgKoopaCapPunchKnockBackR(al::SensorMsg const *); + bool isMsgKoopaCapPunchL(al::SensorMsg const *); + bool isMsgKoopaCapPunchR(al::SensorMsg const *); + bool isMsgKoopaCapSpinAttack(al::SensorMsg const *); + bool isMsgKoopaCatchKoopaCap(al::SensorMsg const *); + bool isMsgKoopaDashPunchAttack(al::SensorMsg const *); + bool isMsgKoopaFire2D(al::SensorMsg const *); + bool isMsgKoopaFireBallAttack(al::SensorMsg const *); + bool isMsgKoopaHackDamage(al::SensorMsg const *); + bool isMsgKoopaHackPunch(al::SensorMsg const *); + bool isMsgKoopaHackPunchCollide(al::SensorMsg const *); + bool isMsgKoopaHackTrample(al::SensorMsg const *); + bool isMsgKoopaInvalidHackPunchFaceToCollision(al::SensorMsg const *); + bool isMsgKoopaRingBeamInvalidTouch(al::SensorMsg const *); + bool isMsgKoopaTailAttack(al::SensorMsg const *); + bool isMsgKoopaTouchFloor(al::SensorMsg const *); + bool isMsgKouraAttack2D(al::SensorMsg const *); + bool isMsgKouraItemGet2D(al::SensorMsg const *); + bool isMsgKuribo2DTouch(al::SensorMsg const *); + bool isMsgKuriboCollisionDamage(al::SensorMsg const *); + bool isMsgKuriboCollisionKill(al::SensorMsg const *); + bool isMsgKuriboFlick(al::SensorMsg const *); + bool isMsgKuriboGirlAttack(al::SensorMsg const *); + bool isMsgKuriboGirlLove(al::SensorMsg const *); + bool isMsgKuriboTop(al::SensorMsg const *); + bool isMsgKuriboTowerNum(al::SensorMsg const *); + bool isMsgLaunchBlow(al::SensorMsg const *); + bool isMsgLineDancerLink(al::SensorMsg const *); + bool isMsgLongPushSensorHit(al::SensorMsg const *); + bool isMsgLongPushBoxHit(al::SensorMsg const *); + bool isMsgMagnetBulletAttack(al::SensorMsg const *); + bool isMsgMeganeAttack(al::SensorMsg const *); + bool isMsgMeganeHackTrample(al::SensorMsg const *); + bool isMsgMofumofuBodyChainExplode(al::SensorMsg const *); + bool isMsgMofumofuBulletUnexplosion(al::SensorMsg const *); + bool isMsgMoonBasementAttackMeteor(al::SensorMsg const *); + bool isMsgMoonBasementBreakShockwaveMeteor(al::SensorMsg const *); + bool isMsgMoonBasementRockSyncClippingRegist(al::SensorMsg const *); + bool isMsgMoonBasementRockSyncClippingInvalidate(al::SensorMsg const *); + bool isMsgMoonBasementRockSyncClippingValidate(al::SensorMsg const *); + bool isMsgMoonBasementRockThroughCollision(al::SensorMsg const *); + bool isMsgMorningStarWarpEnd(al::SensorMsg const *); + bool isMsgMorningStarWarpStart(al::SensorMsg const *); + bool isMsgMotorcycleAttack(al::SensorMsg const *); + bool isMsgMotorcycleCollideParkingLot(al::SensorMsg const *); + bool isMsgMotorcycleDashAttack(al::SensorMsg const *); + bool isMsgMotorcycleDashCollide(al::SensorMsg const *); + bool isMsgCactusNeedleAttack(al::SensorMsg const *); + bool isMsgCactusNeedleAttackStrong(al::SensorMsg const *); + bool isMsgNoLimitTouchJump(al::SensorMsg const *); + bool isMsgNoticePlayerDamage(al::SensorMsg const *); + bool isMsgNpcScareByEnemy(al::SensorMsg const *); + bool isMsgVolleyballNpcScareByEnemy(al::SensorMsg const *); + bool isMsgObjSnapForce(al::SensorMsg const *); + bool isMsgPackunEatCancel(al::SensorMsg const *); + bool isMsgPackunEatEnd(al::SensorMsg const *); + bool isMsgPackunEatStart(al::SensorMsg const *); + bool isMsgPackunEatStartFollow(al::SensorMsg const *); + bool isMsgPaint(al::SensorMsg const *); + bool isMsgPaintTexture(al::SensorMsg const *); + bool isMsgCheckPaintClear(al::SensorMsg const *); + bool isMsgCheckPaintAlpha(al::SensorMsg const *); + bool isMsgPartyPopperSoundAttack(al::SensorMsg const *); + bool isMsgPechoSpot(al::SensorMsg const *); + bool isMsgPlayerBallToss(al::SensorMsg const *); + bool isMsgPlayerCarryCameraSubjectiveStart(al::SensorMsg const *); + bool isMsgPlayerCarryCameraSubjectiveEnd(al::SensorMsg const *); + bool isMsgPlayerCarryShineGetStart(al::SensorMsg const *); + bool isMsgPlayerCarryShineGetEnd(al::SensorMsg const *); + bool isMsgPlayerCapCatch(al::SensorMsg const *); + bool isMsgPlayerCapHipDrop(al::SensorMsg const *); + bool isMsgPlayerCapPush(al::SensorMsg const *); + bool isMsgPlayerCapRecovery(al::SensorMsg const *); + bool isMsgPlayerCapTouchJump(al::SensorMsg const *); + bool isMsgPlayerCapTrample(al::SensorMsg const *); + bool isMsgPlayerCoinDashGet(al::SensorMsg const *); + bool isMsgPlayerEyePriorityTarget(al::SensorMsg const *); + bool isMsgPlayerDisregardHomingAttack(al::SensorMsg const *); + bool isMsgPlayerDisregardTargetMarker(al::SensorMsg const *); + bool isMsgPlayerEquipKoopaCap(al::SensorMsg const *); + bool isMsgPlayerFireBallAttack2D(al::SensorMsg const *); + bool isMsgPlayerFireBallAttack3D(al::SensorMsg const *); + bool isMsgPlayerHipDropDemoTrigger(al::SensorMsg const *); + bool isMsgPlayerHipDropHipDropSwitch(al::SensorMsg const *); + bool isMsgPlayerItemGet2D(al::SensorMsg const *); + bool isMsgPlayerJumpTakeOffFloor(al::SensorMsg const *); + bool isMsgPlayerObjectWallHit(al::SensorMsg const *); + bool isMsgPlayerObjLeapFrog(al::SensorMsg const *); + bool isMsgPlayerPenguinAttack(al::SensorMsg const *); + bool isMsgPlayerPenguinAttackReflect(al::SensorMsg const *); + bool isMsgPlayerPoleClimbKeep(al::SensorMsg const *); + bool isMsgPlayerPoleClimbReaction(al::SensorMsg const *); + bool isMsgPlayerRabbitGet(al::SensorMsg const *); + bool isMsgPlayerRollingObjHit(al::SensorMsg const *); + bool isMsgPlayerRollingWallHitDown(al::SensorMsg const *); + bool isMsgPlayerRollingWallHitMove(al::SensorMsg const *); + bool isMsgPlayerStartGrabCeil(al::SensorMsg const *); + bool isMsgPlayerStartWallJump(al::SensorMsg const *); + bool isMsgPlayerEndGrabCeil(al::SensorMsg const *); + bool isMsgPlayerSwordAttack(al::SensorMsg const *); + bool isMsgPlayerTouchFloorJumpCode(al::SensorMsg const *); + bool isMsgPlayerTrample2D(al::SensorMsg const *); + bool isMsgPlayerUpperPunch2D(al::SensorMsg const *); + bool isMsgPlayerObjUpperPunch2D(al::SensorMsg const *); + bool isMsgPropellerAttack(al::SensorMsg const *); + bool isMsgPukupukuDash(al::SensorMsg const *); + bool isMsgPukupukuKiss(al::SensorMsg const *); + bool isMsgPukupukuRollingAttack(al::SensorMsg const *); + bool isMsgPunchMachinePunchHook(al::SensorMsg const *); + bool isMsgPunchMachinePunchStraight(al::SensorMsg const *); + bool isMsgPunchMachinePunchUpper(al::SensorMsg const *); + bool isMsgPush2D(al::SensorMsg const *); + bool isMsgPushToFish(al::SensorMsg const *); + bool isMsgPushToMotorcycle(al::SensorMsg const *); + bool isMsgPushToPlayer(al::SensorMsg const *); + bool isMsgRadishAttack(al::SensorMsg const *); + bool isMsgRadishReflect(al::SensorMsg const *); + bool isMsgRaceStart(al::SensorMsg const *); + bool isMsgRaceStop(al::SensorMsg const *); + bool isMsgRaceWait(al::SensorMsg const *); + bool isMsgRequestChangeFireFlower(al::SensorMsg const *); + bool isMsgRequestChangeKinokoSuper(al::SensorMsg const *); + bool isMsgRequestPlayerJumpBreakFloor(al::SensorMsg const *); + bool isMsgRequestPlayerJump(al::SensorMsg const *); + bool isMsgRequestPlayerTrampleJump(al::SensorMsg const *); + bool isMsgRequestPlayerSpinJump(al::SensorMsg const *); + bool isMsgRequestSphinxJump(al::SensorMsg const *); + bool isMsgRideOnEnd(al::SensorMsg const *); + bool isMsgRideOnRelease(al::SensorMsg const *); + bool isMsgRideOnStart(al::SensorMsg const *); + bool isMsgRocketFlowerExtension(al::SensorMsg const *); + bool isMsgSandSharkAttack(al::SensorMsg const *); + bool isMsgSeedAttack(al::SensorMsg const *); + bool isMsgSeedAttackBig(al::SensorMsg const *); + bool isMsgSeedAttackHold(al::SensorMsg const *); + bool isMsgSeedItemGet(al::SensorMsg const *); + bool isMsgSeedReflect(al::SensorMsg const *); + bool isMsgSeedTouch(al::SensorMsg const *); + bool isMsgSenobiCancelStretch(al::SensorMsg const *); + bool isMsgSenobiPunchBlockTransparent(al::SensorMsg const *); + bool isMsgSenobiPartsMove(al::SensorMsg const *); + bool isMsgSenobiTrample(al::SensorMsg const *); + bool isMsgShibakenApproach(al::SensorMsg const *); + bool isMsgShibakenKick(al::SensorMsg const *); + bool isMsgSkaterAttack(al::SensorMsg const *); + bool isMsgSpherePush(al::SensorMsg const *); + bool isMsgSphinxJumpAttack(al::SensorMsg const *); + bool isMsgSphinxQuizRouteKill(al::SensorMsg const *); + bool isMsgSphinxRideAttack(al::SensorMsg const *); + bool isMsgSphinxRideAttackReflect(al::SensorMsg const *); + bool isMsgSphinxRideAttackTouchThrough(al::SensorMsg const *); + bool isMsgSphinxRideAttackTouch(al::SensorMsg const *); + bool isMsgStampTo2D(al::SensorMsg const *); + bool isMsgStartHack(al::SensorMsg const *); + bool isMsgStartInSaucePan(al::SensorMsg const *); + bool isMsgStatueDrop(al::SensorMsg const *); + bool isMsgStatueTrampleReflect(al::SensorMsg const *); + bool isMsgStatuePush(al::SensorMsg const *); + bool isMsgStatueSnap(al::SensorMsg const *); + bool isMsgSunshineAttack(al::SensorMsg const *); + bool isMsgTankBullet(al::SensorMsg const *); + bool isMsgTankBulletNoReaction(al::SensorMsg const *); + bool isMsgTankExplosion(al::SensorMsg const *); + bool isMsgTankHackTrample(al::SensorMsg const *); + bool isMsgTankKickHack(al::SensorMsg const *); + bool isMsgTankKickEnemy(al::SensorMsg const *); + bool isMsgTankLookOn(al::SensorMsg const *); + bool isMsgTestPunch(al::SensorMsg const *); + bool isMsgTestPunchStrong(al::SensorMsg const *); + bool isMsgTimerAthleticDemoStart(al::SensorMsg const *); + bool isMsgTouchDoorDrumn(al::SensorMsg const *); + bool isMsgTouchFireDrum2D(al::SensorMsg const *); + bool isMsgTrashBoxIn(al::SensorMsg const *); + bool isMsgTRexAttack(al::SensorMsg const *); + bool isMsgTRexAttackCollideAll(al::SensorMsg const *); + bool isMsgTRexAttackCollideBody(al::SensorMsg const *); + bool isMsgTRexAttackCollideHead(al::SensorMsg const *); + bool isMsgTRexDashAttack(al::SensorMsg const *); + bool isMsgTRexScrollPartsBreakWith(al::SensorMsg const *); + bool isMsgTsukkunForceCancelCollide(al::SensorMsg const *); + bool isMsgTsukkunHoldCollide(al::SensorMsg const *); + bool isMsgTsukkunThroughCollide(al::SensorMsg const *); + bool isMsgTsukkunThrustAll(al::SensorMsg const *); + bool isMsgTsukkunThrust(al::SensorMsg const *, bool *); + bool isMsgTsukkunThrustCollide(al::SensorMsg const *, bool *); + bool isMsgTsukkunNoTrace(al::SensorMsg const *); + bool isMsgTsukkunThrustHole(al::SensorMsg const *); + bool isMsgUtsuboAttack(al::SensorMsg const *); + bool isMsgWanderBossCameraRange(al::SensorMsg const *); + bool isMsgWanwanEnemyAttack(al::SensorMsg const *); + bool isMsgWanwanBlockAttack(al::SensorMsg const *); + bool isMsgWanwanHoleIn(al::SensorMsg const *); + bool isMsgWaterRoadIn(al::SensorMsg const *); + bool isMsgWaterRoadNear(al::SensorMsg const *); + bool isMsgWanwanPush(al::SensorMsg const *); + bool isMsgWanwanReboundAttack(al::SensorMsg const *); + bool isMsgWeaponItemGet(al::SensorMsg const *); + bool isMsgWhipAttack(al::SensorMsg const *); + bool isMsgWhipBind(al::SensorMsg const *); + bool isMsgWhipHold(al::SensorMsg const *); + bool isMsgWhipThrow(al::SensorMsg const *); + bool isMsgYokinBallAttack(al::SensorMsg const *); + bool isMsgYoshiDirectEat(al::SensorMsg const *); + bool isMsgYoshiTongueAttack(al::SensorMsg const *); + bool isMsgYoshiTongueEatBind(al::SensorMsg const *); + bool isMsgYoshiTongueEatBindCancel(al::SensorMsg const *); + bool isMsgYoshiTongueEatBindFinish(al::SensorMsg const *); + bool isMsgYoshiTongueEatHomingTarget(al::SensorMsg const *); + bool isMsgYukimaruPush(al::SensorMsg const *); + bool isMsgKillerAttackNoExplode(al::SensorMsg const *); + bool isMsgKillerMagnumAttack(al::SensorMsg const *); + bool isMsgKillerMagnumHackAttack(al::SensorMsg const *); + bool isMsgGabuzouAttack(al::SensorMsg const *); + bool isMsgStackerRollingAttack(al::SensorMsg const *); + bool isMsgStackerCapBoostAttack(al::SensorMsg const *); + bool isMsgIgnoreIgnitionBomb(al::SensorMsg const *); + bool isMsgExplosionReflectBomb(al::SensorMsg const *); + bool isMsgGolemStampPress(al::SensorMsg const *); + bool isMsgTsukkunThrustSpin(al::SensorMsg const *, bool *); + bool isMsgTsukkunThrustReflect(al::SensorMsg const *, bool *); + bool isMsgTsukkunThrustHitReflectCollide(al::SensorMsg const *, bool *); + bool isMsgTsukkunThrustReflectCollide(al::SensorMsg const *, bool *); + bool isMsgSwitchOnWithSaveRequest(al::SensorMsg const *, SaveObjInfo **); + bool isMsgNpcCapReactionAll(al::SensorMsg const *); + bool isMsgHackNpcCapReactionAll(al::SensorMsg const *); + bool isMsgPlayerAndCapObjHipDropReflectAll(al::SensorMsg const *); + bool isMsgKoopaCapPunchAll(al::SensorMsg const *); + bool isMsgKoopaCapPunchInvincibleAll(al::SensorMsg const *); + bool isMsgKoopaCapPunchFinishAll(al::SensorMsg const *); + bool isMsgItemGet(al::SensorMsg const *); + bool isMsgItemGetByWeapon(al::SensorMsg const *); + bool isMsgItemGet2D(al::SensorMsg const *); + bool isMsgBlockUpperPunch2D(al::SensorMsg const *); + bool isMsgItemGetAll(al::SensorMsg const *); + bool isMsgShineGet(al::SensorMsg const *); + bool isMsgShineGet2D(al::SensorMsg const *); + bool isMsgShineReaction(al::SensorMsg const *); + bool isMsgKillByShineGet(al::SensorMsg const *); + bool isMsgKillByHomeDemo(al::SensorMsg const *); + bool isMsgEndHomeDemo(al::SensorMsg const *); + bool isMsgBreakBySword(al::SensorMsg const *); + bool isMsgPressDown(al::SensorMsg const *); + bool isMsgPlayerAndCapObjHipDropAll(al::SensorMsg const *); + bool isMsgAttackDirect(al::SensorMsg const *); + bool isMsgBlowDown(al::SensorMsg const *); + bool isMsgTrampleReflectAll(al::SensorMsg const *); + bool isMsgThrowObjHit(al::SensorMsg const *); + bool isMsgThrowObjHitReflect(al::SensorMsg const *); + bool isMsgPlayerAndCapHipDropAll(al::SensorMsg const *); + bool isMsgUpperPunchAll(al::SensorMsg const *); + bool isMsgBlockReaction2D(al::SensorMsg const *); + bool isMsgBlockReaction3D(al::SensorMsg const *); + bool isMsgBlockReactionAll(al::SensorMsg const *); + bool isMsgBreakFrailBox(al::SensorMsg const *); + bool isMsgDamageFrailBox(al::SensorMsg const *); + bool isMsgChorobonReaction(al::SensorMsg const *); + bool isMsgBreakSignBoard(al::SensorMsg const *); + bool isMsgBreakCollapseSandHill(al::SensorMsg const *); + bool isMsgPlayerDamage(al::SensorMsg const *); + bool isMsgPlayerDamage2D(al::SensorMsg const *); + bool isMsgPlayerDamageBlowDown(al::SensorMsg const *); + bool isMsgPlayerJumpRequestAll(al::SensorMsg const *); + bool isMsgDashPanel(al::SensorMsg const *, int *); + bool isMsgNetworkShootingShot(al::SensorMsg const *, int); + bool isMsgNetworkShootingChargeShot(al::SensorMsg const *, int); + bool isMsgRaceReturnToCourse(al::SensorMsg const *, sead::Vector3f *, sead::Vector3f *); + bool isMsgTrampolineCrackJump(float *, float *, al::SensorMsg const *); + bool isMsgGotogotonOn(al::SensorMsg const *); + bool isMsgGotogotonGoalExist(al::SensorMsg const *); + bool isMsgBossMagmaCatchPlayer(al::SensorMsg const *); + bool isMsgBossMagmaReleasePlayer(al::SensorMsg const *); + bool isMsgBossMagmaDeadDemoStart(al::SensorMsg const *); + bool isMsgBossMagmaDeadDemoEnd(al::SensorMsg const *); + bool isMsgBossMagmaQueryToBubble(al::SensorMsg const *); + bool isMsgMofumofuReflectAll(al::SensorMsg const *); + bool isMsgCheckFishingTarget(al::SensorMsg const *); + bool isMsgPlayerLookAtPosition(al::SensorMsg const *); + bool isMsgTargetMarkerPosition(al::SensorMsg const *); + bool isMsgSandGeyserRaise(al::SensorMsg const *); + bool isMsgInitCapTarget(al::SensorMsg const *); + bool isMsgTransferHack(al::SensorMsg const *); + bool isMsgRequestTransferHack(al::SensorMsg const *); + bool isMsgInitHack(al::SensorMsg const *); + bool isMsgEndHack(HackEndParam const **, al::SensorMsg const *); + bool isMsgHackDirectStageInit(IUsePlayerHack **, al::SensorMsg const *); + bool isMsgKillByBossBattleDemo(al::SensorMsg const *); + bool isMsgKillByHackFirstDemo(al::SensorMsg const *); + bool isMsgKillByMoonRockDemo(al::SensorMsg const *); + bool isMsgKillBySwitchTimer(al::SensorMsg const *); +} + +namespace al +{ + bool isMsgRequestPlayerStainWet(al::SensorMsg const *, int *); + bool isMsgPushAll(al::SensorMsg const *); + bool isMsgPush(al::SensorMsg const *); + bool isMsgPushStrong(al::SensorMsg const *); + bool isMsgPushVeryStrong(al::SensorMsg const *); + bool isMsgHoldReleaseAll(al::SensorMsg const *); + bool isMsgHoldCancel(al::SensorMsg const *); + bool isMsgPlayerRelease(al::SensorMsg const *); + bool isMsgPlayerReleaseBySwing(al::SensorMsg const *); + bool isMsgPlayerReleaseDead(al::SensorMsg const *); + bool isMsgPlayerReleaseDamage(al::SensorMsg const *); + bool isMsgPlayerReleaseDemo(al::SensorMsg const *); + bool isMsgItemGetDirectAll(al::SensorMsg const *); + bool isMsgPlayerItemGet(al::SensorMsg const *); + bool isMsgRideAllPlayerItemGet(al::SensorMsg const *); + bool isMsgPlayerTailAttack(al::SensorMsg const *); + bool isMsgItemGetByObjAll(al::SensorMsg const *); + bool isMsgBallItemGet(al::SensorMsg const *); + bool isMsgKickKouraItemGet(al::SensorMsg const *); + bool isMsgKillerItemGet(al::SensorMsg const *); + bool isMsgItemGetAll(al::SensorMsg const *); + bool isMsgFloorTouch(al::SensorMsg const *); + bool isMsgPlayerFloorTouch(al::SensorMsg const *); + bool isMsgEnemyFloorTouch(al::SensorMsg const *); + bool isMsgUpperPunch(al::SensorMsg const *); + bool isMsgPlayerUpperPunch(al::SensorMsg const *); + bool isMsgEnemyUpperPunch(al::SensorMsg const *); + bool isMsgPlayerTrample(al::SensorMsg const *); + bool isMsgPlayerTrampleReflect(al::SensorMsg const *); + bool isMsgPlayerHipDropAll(al::SensorMsg const *); + bool isMsgPlayerStatueDrop(al::SensorMsg const *); + bool isMsgPlayerObjHipDropAll(al::SensorMsg const *); + bool isMsgPlayerObjStatueDrop(al::SensorMsg const *); + bool isMsgPlayerObjHipDropReflectAll(al::SensorMsg const *); + bool isMsgPlayerObjStatueDropReflect(al::SensorMsg const *); + bool isMsgPlayerObjHipDropHighJump(al::SensorMsg const *); + bool isMsgPlayerHipDropKnockDown(al::SensorMsg const *); + bool isMsgPlayerObjStatueDropReflectNoCondition(al::SensorMsg const *); + bool isMsgPlayerStatueTouch(al::SensorMsg const *); + bool isMsgPlayerObjUpperPunch(al::SensorMsg const *); + bool isMsgPlayerRollingAttack(al::SensorMsg const *); + bool isMsgPlayerRollingReflect(al::SensorMsg const *); + bool isMsgPlayerObjRollingAttack(al::SensorMsg const *); + bool isMsgPlayerObjRollingAttackFailure(al::SensorMsg const *); + bool isMsgPlayerInvincibleAttack(al::SensorMsg const *); + bool isMsgPlayerFireBallAttack(al::SensorMsg const *); + bool isMsgPlayerRouteDokanFireBallAttack(al::SensorMsg const *); + bool isMsgPlayerKick(al::SensorMsg const *); + bool isMsgPlayerCatch(al::SensorMsg const *); + bool isMsgPlayerSlidingAttack(al::SensorMsg const *); + bool isMsgPlayerBoomerangAttack(al::SensorMsg const *); + bool isMsgPlayerBoomerangAttackCollide(al::SensorMsg const *); + bool isMsgPlayerBoomerangReflect(al::SensorMsg const *); + bool isMsgPlayerBoomerangBreak(al::SensorMsg const *); + bool isMsgPlayerBodyAttack(al::SensorMsg const *); + bool isMsgPlayerBodyLanding(al::SensorMsg const *); + bool isMsgPlayerBodyAttackReflect(al::SensorMsg const *); + bool isMsgPlayerClimbAttack(al::SensorMsg const *); + bool isMsgPlayerSpinAttack(al::SensorMsg const *); + bool isMsgPlayerGiantAttack(al::SensorMsg const *); + bool isMsgPlayerCooperationHipDrop(al::SensorMsg const *); + bool isMsgPlayerClimbSlidingAttack(al::SensorMsg const *); + bool isMsgPlayerClimbRollingAttack(al::SensorMsg const *); + bool isMsgPlayerGiantHipDrop(al::SensorMsg const *); + bool isMsgPlayerDisregard(al::SensorMsg const *); + bool isMsgPlayerDash(al::SensorMsg const *); + bool isMsgPlayerDamageTouch(al::SensorMsg const *); + bool isMsgPlayerFloorTouchBind(al::SensorMsg const *); + bool isMsgPlayerTouch(al::SensorMsg const *); + bool isMsgPlayerInvincibleTouch(al::SensorMsg const *); + bool isMsgPlayerGiantTouch(al::SensorMsg const *); + bool isMsgPlayerObjTouch(al::SensorMsg const *); + bool isMsgPlayerPutOnEquipment(al::SensorMsg const *); + bool isMsgPlayerReleaseEquipment(al::SensorMsg const *); + bool isMsgPlayerReleaseEquipmentGoal(al::SensorMsg const *); + bool isMsgPlayerCarryFront(al::SensorMsg const *); + bool isMsgPlayerCarryFrontWallKeep(al::SensorMsg const *); + bool isMsgPlayerCarryUp(al::SensorMsg const *); + bool isMsgPlayerCarryKeepDemo(al::SensorMsg const *); + bool isMsgPlayerCarryWarp(al::SensorMsg const *); + bool isMsgPlayerLeave(al::SensorMsg const *); + bool isMsgPlayerToss(al::SensorMsg const *); + bool isMsgEnemyAttack(al::SensorMsg const *); + bool isMsgEnemyAttackFire(al::SensorMsg const *); + bool isMsgEnemyAttackKnockDown(al::SensorMsg const *); + bool isMsgEnemyAttackBoomerang(al::SensorMsg const *); + bool isMsgEnemyAttackNeedle(al::SensorMsg const *); + bool isMsgEnemyItemGet(al::SensorMsg const *); + bool isMsgEnemyRouteDokanAttack(al::SensorMsg const *); + bool isMsgEnemyRouteDokanFire(al::SensorMsg const *); + bool isMsgExplosion(al::SensorMsg const *); + bool isMsgExplosionCollide(al::SensorMsg const *); + bool isMsgBindStart(al::SensorMsg const *); + bool isMsgBindInit(al::SensorMsg const *); + bool isMsgBindEnd(al::SensorMsg const *); + bool isMsgBindCancel(al::SensorMsg const *); + bool isMsgBindCancelByDemo(al::SensorMsg const *); + bool isMsgBindDamage(al::SensorMsg const *); + bool isMsgBindSteal(al::SensorMsg const *); + bool isMsgBindGiant(al::SensorMsg const *); + bool isMsgPressureDeath(al::SensorMsg const *); + bool isMsgNpcTouch(al::SensorMsg const *); + bool isMsgHit(al::SensorMsg const *); + bool isMsgHitStrong(al::SensorMsg const *); + bool isMsgHitVeryStrong(al::SensorMsg const *); + bool isMsgKnockDown(al::SensorMsg const *); + bool isMsgMapPush(al::SensorMsg const *); + bool isMsgVanish(al::SensorMsg const *); + bool isMsgChangeAlpha(al::SensorMsg const *); + bool isMsgShowModel(al::SensorMsg const *); + bool isMsgHideModel(al::SensorMsg const *); + bool isMsgRestart(al::SensorMsg const *); + bool isMsgEnemyTouch(al::SensorMsg const *); + bool isMsgEnemyTrample(al::SensorMsg const *); + bool isMsgMapObjTrample(al::SensorMsg const *); + bool isMsgNeedleBallAttack(al::SensorMsg const *); + bool isMsgPunpunFloorTouch(al::SensorMsg const *); + bool isMsgInvalidateFootPrint(al::SensorMsg const *); + bool isMsgKickKouraAttack(al::SensorMsg const *); + bool isMsgKickKouraAttackCollide(al::SensorMsg const *); + bool isMsgKickKouraReflect(al::SensorMsg const *); + bool isMsgKickKouraCollideNoReflect(al::SensorMsg const *); + bool isMsgKickKouraBreak(al::SensorMsg const *); + bool isMsgKickKouraBlow(al::SensorMsg const *); + bool isMsgKickStoneAttack(al::SensorMsg const *); + bool isMsgKickStoneAttackCollide(al::SensorMsg const *); + bool isMsgKickStoneAttackHold(al::SensorMsg const *); + bool isMsgKickStoneAttackReflect(al::SensorMsg const *); + bool isMsgKickStoneTrample(al::SensorMsg const *); + bool isMsgKillerAttack(al::SensorMsg const *); + bool isMsgLiftGeyser(al::SensorMsg const *); + bool isMsgWarpStart(al::SensorMsg const *); + bool isMsgWarpEnd(al::SensorMsg const *); + bool isMsgHoleIn(al::SensorMsg const *); + bool isMsgJumpInhibit(al::SensorMsg const *); + bool isMsgGoalKill(al::SensorMsg const *); + bool isMsgGoal(al::SensorMsg const *); + bool isMsgBallAttack(al::SensorMsg const *); + bool isMsgBallRouteDokanAttack(al::SensorMsg const *); + bool isMsgBallAttackHold(al::SensorMsg const *); + bool isMsgBallAttackDRCHold(al::SensorMsg const *); + bool isMsgBallAttackCollide(al::SensorMsg const *); + bool isMsgBallTrample(al::SensorMsg const *); + bool isMsgBallTrampleCollide(al::SensorMsg const *); + bool isMsgFireBallCollide(al::SensorMsg const *); + bool isMsgFireBallFloorTouch(al::SensorMsg const *); + bool isMsgDokanBazookaAttack(al::SensorMsg const *); + bool isMsgSwitchOn(al::SensorMsg const *); + bool isMsgSwitchOnInit(al::SensorMsg const *); + bool isMsgSwitchOffInit(al::SensorMsg const *); + bool isMsgSwitchKillOn(al::SensorMsg const *); + bool isMsgSwitchKillOnInit(al::SensorMsg const *); + bool isMsgSwitchKillOffInit(al::SensorMsg const *); + bool isMsgAskSafetyPoint(al::SensorMsg const *); + bool isMsgTouchAssist(al::SensorMsg const *); + bool isMsgTouchAssistNoPat(al::SensorMsg const *); + bool isMsgTouchAssistTrig(al::SensorMsg const *); + bool isMsgTouchAssistTrigOff(al::SensorMsg const *); + bool isMsgTouchAssistTrigNoPat(al::SensorMsg const *); + bool isMsgTouchAssistBurn(al::SensorMsg const *); + bool isMsgTouchAssistAll(al::SensorMsg const *); + bool isMsgTouchCarryItem(al::SensorMsg const *); + bool isMsgTouchReleaseItem(al::SensorMsg const *); + bool isMsgTouchStroke(al::SensorMsg const *); + bool isMsgIsNerveSupportFreeze(al::SensorMsg const *); + bool isMsgOnSyncSupportFreeze(al::SensorMsg const *); + bool isMsgOffSyncSupportFreeze(al::SensorMsg const *); + bool isMsgScreenPointInvalidCollisionParts(al::SensorMsg const *); + bool isMsgBlockUpperPunch(al::SensorMsg const *); + bool isMsgBlockLowerPunch(al::SensorMsg const *); + bool isMsgBlockItemGet(al::SensorMsg const *); + bool isMsgPlayerKouraAttack(al::SensorMsg const *); + bool isMsgLightFlash(al::SensorMsg const *); + bool isMsgForceAbyss(al::SensorMsg const *); + bool isMsgSwordAttackHigh(al::SensorMsg const *); + bool isMsgSwordAttackHighLeft(al::SensorMsg const *); + bool isMsgSwordAttackHighRight(al::SensorMsg const *); + bool isMsgSwordAttackLow(al::SensorMsg const *); + bool isMsgSwordAttackLowLeft(al::SensorMsg const *); + bool isMsgSwordAttackLowRight(al::SensorMsg const *); + bool isMsgSwordBeamAttack(al::SensorMsg const *); + bool isMsgSwordBeamReflectAttack(al::SensorMsg const *); + bool isMsgSwordAttackJumpUnder(al::SensorMsg const *); + bool isMsgShieldGuard(al::SensorMsg const *); + bool isMsgAskMultiPlayerEnemy(al::SensorMsg const *); + bool isMsgItemGettable(al::SensorMsg const *); + bool isMsgKikkiThrow(al::SensorMsg const *); + bool isMsgIsKikkiThrowTarget(al::SensorMsg const *); + bool isMsgPlayerCloudGet(al::SensorMsg const *); + bool isMsgAutoJump(al::SensorMsg const *); + bool isMsgPlayerTouchShadow(al::SensorMsg const *); + bool isMsgPlayerPullOutShadow(al::SensorMsg const *); + bool isMsgPlayerAttackShadow(al::SensorMsg const *); + bool isMsgPlayerAttackShadowStrong(al::SensorMsg const *); + bool isMsgPlayerAttackChangePos(al::SensorMsg const *); + bool isMsgAtmosOnlineLight(al::SensorMsg const *); + bool isMsgLightBurn(al::SensorMsg const *); + bool isMsgMoonLightBurn(al::SensorMsg const *); + bool isMsgString(al::SensorMsg const *); + bool isMsgStringV4fPtr(al::SensorMsg const *); + bool isMsgStringV4fSensorPtr(al::SensorMsg const *); + bool isMsgStringVoidPtr(al::SensorMsg const *); + bool isMsgPlayerTrampleForCrossoverSensor(al::SensorMsg const *, al::HitSensor const *, al::HitSensor const *); + bool isMsgPlayerTrampleReflectForCrossoverSensor(al::SensorMsg const *, al::HitSensor const *, al::HitSensor const *); + bool isMsgPlayerUpperPunchForCrossoverSensor(al::SensorMsg const *, al::HitSensor const *, al::HitSensor const *, float); + bool isMsgKickStoneTrampleForCrossoverSensor(al::SensorMsg const *, al::HitSensor const *, al::HitSensor const *); + +} // namespace al diff --git a/include/al/sensor/SensorMsg.h b/include/al/sensor/SensorMsg.h index ca5b547..c9c9771 100644 --- a/include/al/sensor/SensorMsg.h +++ b/include/al/sensor/SensorMsg.h @@ -1,6 +1,7 @@ #pragma once #include "SendMsg.h" +#include "IsMsg.h" namespace al { diff --git a/include/al/util.hpp b/include/al/util.hpp index 1f0acdb..dd5e8cf 100644 --- a/include/al/util.hpp +++ b/include/al/util.hpp @@ -130,10 +130,16 @@ namespace al char const *getActionName(al::LiveActor const *); - char const *getActionFrame(al::LiveActor const *); + float getActionFrame(al::LiveActor const *); + + int getActionFrameMax(al::LiveActor const *); + + bool isActionEnd(al::LiveActor const *); // setters + void setActionFrameRate(al::LiveActor *, float); + void setTransY(al::LiveActor *, float); void setTrans(al::LiveActor *, sead::Vector3f const &); diff --git a/include/customLiveActor.hpp b/include/customLiveActor.hpp index e75e99d..5237542 100644 --- a/include/customLiveActor.hpp +++ b/include/customLiveActor.hpp @@ -4,13 +4,13 @@ #include "al/util/NerveUtil.h" #include "logger.hpp" -// cal = custom actor libray -namespace cal +// ca = custom actor(s) +namespace ca { - class DeathBlockBrick : public al::LiveActor + class BlockShine : public al::LiveActor { public: - DeathBlockBrick(const char *name); + BlockShine(const char *name); virtual void init(al::ActorInitInfo const &) override; virtual void initAfterPlacement(void) override; virtual bool receiveMsg(const al::SensorMsg *message, al::HitSensor *source, al::HitSensor *target) override; @@ -18,13 +18,17 @@ namespace cal virtual void control(void) override; void exeWait(); + void exeReaction(); + void exeReactionHipDrop(); void exeDead(); }; namespace { - NERVE_HEADER(DeathBlockBrick, Wait) - NERVE_HEADER(DeathBlockBrick, Dead) + NERVE_HEADER(BlockShine, Wait) + NERVE_HEADER(BlockShine, Dead) + NERVE_HEADER(BlockShine, Reaction) + NERVE_HEADER(BlockShine, ReactionHipDrop) } } diff --git a/patches/codehook.slpatch b/patches/codehook.slpatch index e6aac94..b600dc4 100644 --- a/patches/codehook.slpatch +++ b/patches/codehook.slpatch @@ -1,10 +1,6 @@ [version=100, target=main] StageScene::control+18: BL stageSceneHook -<<<<<<< HEAD - -======= ->>>>>>> d9f97d1785079d0fc96363d314c2b13c6bd6c5f2 4C8648: // hook to the init of a stage to modify certain conditions (we also have access to SceneInitInfo) BL stageInitHook @@ -13,7 +9,6 @@ StageScene::control+18: BL tryInitSocket B59E28: // sead::system::print B seadPrintHook -<<<<<<< HEAD 5359DC: MOV X0, X19 // move GameSystem to arg register BL setupDebugMenu @@ -26,19 +21,12 @@ B59E28: // sead::system::print //50E89C: // BL threadInit -======= ->>>>>>> d9f97d1785079d0fc96363d314c2b13c6bd6c5f2 //4C8958: // BL initDebugListHook -<<<<<<< HEAD 1B3F0C: // disables call to open HTML viewer during first time odyssey flight NOP -======= -50E89C: - BL threadInit ->>>>>>> d9f97d1785079d0fc96363d314c2b13c6bd6c5f2 1F2A2C: // patches checkpoint system to always allow warping MOV W0, #1 @@ -55,6 +43,6 @@ B59E28: // sead::system::print RET // Snapshot Button Disabling -576FB8: // rs::isTriggerSnapShotMode - MOV X0, #0 - RET \ No newline at end of file +//576FB8: // rs::isTriggerSnapShotMode +// MOV X0, #0 +// RET \ No newline at end of file diff --git a/romfs/ObjectData/BlockShine.szs b/romfs/ObjectData/BlockShine.szs new file mode 100644 index 0000000..8f30f50 Binary files /dev/null and b/romfs/ObjectData/BlockShine.szs differ diff --git a/romfs/ObjectData/DeathBlockBrick.szs b/romfs/ObjectData/DeathBlockBrick.szs deleted file mode 100644 index 22a6e07..0000000 Binary files a/romfs/ObjectData/DeathBlockBrick.szs and /dev/null differ diff --git a/romfs/StageData/CapWorldHomeStageMap.szs b/romfs/StageData/CapWorldHomeStageMap.szs index 09441f8..2766ce9 100644 Binary files a/romfs/StageData/CapWorldHomeStageMap.szs and b/romfs/StageData/CapWorldHomeStageMap.szs differ diff --git a/scripts/sendPatch.py b/scripts/sendPatch.py index 3af71d7..b74e9a5 100644 --- a/scripts/sendPatch.py +++ b/scripts/sendPatch.py @@ -37,10 +37,9 @@ if '.' not in consoleIP: consolePort = 5000 -if len(sys.argv) < 2: - projName = 'StarlightBase' -else: - projName = sys.argv[1] +projName = sys.argv[2] +username = sys.argv[3] +password = sys.argv[4] curDir = os.curdir @@ -49,7 +48,7 @@ ftp = FTP() print(f'Connecting to {consoleIP}... ', end='') ftp.connect(consoleIP, consolePort) print('logging into server...', end='') -ftp.login('username','password') # put username and password in here +ftp.login(username, password) print('Connected!') patchDirectories = [] @@ -74,9 +73,6 @@ for patchDir in patchDirectories: sdPath = f'/atmosphere/exefs_patches/{projName}/{file}' print(f'Sending "{sdPath}" to {consoleIP}.') ftp.storbinary(f'STOR {sdPath}', open(fullPath, 'rb')) - if isNeedOtherSwitch: - print(f'Sending "{sdPath}" to {altSwitchIP}.') - otherftp.storbinary(f'STOR {sdPath}', open(fullPath, 'rb')) ensuredirectory(ftp, '/atmosphere', 'contents') ensuredirectory(ftp, '/atmosphere/contents', '0100000000010000') @@ -88,6 +84,3 @@ if os.path.isfile(binaryPath): sdPath = f'/atmosphere/contents/0100000000010000/exefs/subsdk1' print(f'Sending "{sdPath}" to {consoleIP}.') ftp.storbinary(f'STOR {sdPath}', open(binaryPath, 'rb')) - if isNeedOtherSwitch: - print(f'Sending "{sdPath}" to {altSwitchIP}.') - otherftp.storbinary(f'STOR {sdPath}', open(binaryPath, 'rb')) diff --git a/source/customLiveActor.cpp b/source/customLiveActor.cpp index 45906c1..e4a91a7 100644 --- a/source/customLiveActor.cpp +++ b/source/customLiveActor.cpp @@ -1,10 +1,10 @@ #include "customLiveActor.hpp" -namespace cal +namespace ca { - DeathBlockBrick::DeathBlockBrick(const char *name) : al::LiveActor(name) {} + BlockShine::BlockShine(const char *name) : al::LiveActor(name) {} - void DeathBlockBrick::init(al::ActorInitInfo const &info) + void BlockShine::init(al::ActorInitInfo const &info) { al::initMapPartsActor(this, info, nullptr); @@ -14,28 +14,34 @@ namespace cal this->makeActorAlive(); } - void DeathBlockBrick::initAfterPlacement(void) + void BlockShine::initAfterPlacement(void) { return; } - bool DeathBlockBrick::receiveMsg(const al::SensorMsg *message, al::HitSensor *source, al::HitSensor *target) + bool BlockShine::receiveMsg(const al::SensorMsg *message, al::HitSensor *source, al::HitSensor *target) { - if (al::isSensorPlayerAttack(target)) + if (rs::isMsgUpperPunchAll(message)) { - // do something + al::setNerve(this, &nrvReaction); + return true; + } + else if (rs::isMsgPlayerAndCapHipDropAll(message)) + { + al::setNerve(this, &nrvReactionHipDrop); + return true; } return false; } - bool DeathBlockBrick::attackSensor(al::HitSensor *target, al::HitSensor *source) + bool BlockShine::attackSensor(al::HitSensor *target, al::HitSensor *source) { return false; } - void DeathBlockBrick::control(void) { return; } + void BlockShine::control(void) { return; } - void DeathBlockBrick::exeWait() + void BlockShine::exeWait() { if (al::isFirstStep(this)) { @@ -43,18 +49,46 @@ namespace cal } } - void DeathBlockBrick::exeDead() + void BlockShine::exeReaction() { if (al::isFirstStep(this)) { - // do something + al::startAction(this, "Reaction"); + al::setActionFrameRate(this, 0.6); + } + else if (al::isActionEnd(this)) + { + al::setNerve(this, &nrvDead); + } + } + + void BlockShine::exeReactionHipDrop() + { + if (al::isFirstStep(this)) + { + al::startAction(this, "ReactionHipDrop"); + al::setActionFrameRate(this, 0.6); + } + else if (al::isActionEnd(this)) + { + al::setNerve(this, &nrvDead); + } + } + + void BlockShine::exeDead() + { + if (al::isFirstStep(this)) + { + this->kill(); } } namespace { - NERVE_IMPL(DeathBlockBrick, Wait) - NERVE_IMPL(DeathBlockBrick, Dead) + NERVE_IMPL(BlockShine, Wait) + NERVE_IMPL(BlockShine, Reaction) + NERVE_IMPL(BlockShine, ReactionHipDrop) + NERVE_IMPL(BlockShine, Dead) } // namespace } // namespace cal diff --git a/source/logger.cpp b/source/logger.cpp index 780bf65..aab9312 100644 --- a/source/logger.cpp +++ b/source/logger.cpp @@ -2,7 +2,6 @@ Logger *gLogger; -<<<<<<< HEAD void Logger::init() { in_addr hostAddress = {0}; @@ -93,77 +92,5 @@ bool Logger::pingSocket() void tryInitSocket() { __asm("STR X20, [X8,#0x18]"); - // note that this uses a different port, because running the debug logger must use a different server that only accepts strings instead of packets (im lazy like that) gLogger = new Logger(GLOBALDEBUGIP, 3080, "MainLogger"); // PLACE LOCAL PC IP ADDRESS HERE -======= -void Logger::init() { - in_addr hostAddress = { 0 }; - sockaddr serverAddress = { 0 }; - - if (this->socket_log_state != SOCKET_LOG_UNINITIALIZED) - return; - - nn::nifm::Initialize(); - nn::nifm::SubmitNetworkRequest(); - - while (nn::nifm::IsNetworkRequestOnHold()) { } - - if (!nn::nifm::IsNetworkAvailable()) { - this->socket_log_state = SOCKET_LOG_UNAVAILABLE; - return; - } - - // nn::socket::Initialize(socket_data_pool, 0x600000, 0x20000, 14); - - if ((this->socket_log_socket = nn::socket::Socket(2, 1, 0)) < 0) { - this->socket_log_state = SOCKET_LOG_UNAVAILABLE; - return; - } - - nn::socket::InetAton(this->sock_ip, &hostAddress); - - serverAddress.address = hostAddress; - serverAddress.port = nn::socket::InetHtons(this->port); - serverAddress.family = 2; - - if (nn::socket::Connect(this->socket_log_socket, &serverAddress, sizeof(serverAddress)) != 0) { - this->socket_log_state = SOCKET_LOG_UNAVAILABLE; - return; - } - - this->socket_log_state = SOCKET_LOG_CONNECTED; -} - -void Logger::LOG(const char *fmt, ...) { - va_list args; - va_start(args, fmt); - - char buf[0x500]; - - if (nn::util::VSNPrintf(buf, sizeof(buf), fmt, args) > 0) { - - char prefix[0x100]; - nn::util::SNPrintf(prefix, sizeof(prefix), "[%s] %s", this->sockName, buf); - socket_log(prefix); - } - - va_end(args); -} - -void Logger::LOG(const char *fmt, va_list args) { // impl for replacing seads system::print - char buf[0x500]; - if (nn::util::VSNPrintf(buf, sizeof(buf), fmt, args) > 0) { - socket_log(buf); - } ->>>>>>> d9f97d1785079d0fc96363d314c2b13c6bd6c5f2 -} - -s32 Logger::READ(char *out) { - return this->socket_read_char(out); -} - -void tryInitSocket() { - __asm("STR X20, [X8,#0x18]"); - //gLogger = new Logger("10.0.0.224", 1337, "MainLogger"); // Home IP - gLogger = new Logger("192.168.1.75", 1337, "MainLogger"); // Apartment IP } \ No newline at end of file diff --git a/source/seadNew.cpp b/source/seadNew.cpp index accc094..2202a72 100644 --- a/source/seadNew.cpp +++ b/source/seadNew.cpp @@ -8,185 +8,163 @@ namespace sead { namespace system { - void* NewImpl(Heap* heap, size_t size, s32 alignment, bool abortOnFailure); - void DeleteImpl(void* ptr); - } // namespace system -} // namespace sead + void *NewImpl(Heap *heap, size_t size, s32 alignment, bool abortOnFailure); + void DeleteImpl(void *ptr); + } // namespace system +} // namespace sead // operator new(size_t) -void* operator new(size_t size) +void *operator new(size_t size) { return sead::system::NewImpl(nullptr, size, 8, true); } -void* operator new[](size_t size) +void *operator new[](size_t size) { return sead::system::NewImpl(nullptr, size, 8, true); } -<<<<<<< HEAD -void* operator new(size_t size, const std::nothrow_t&) noexcept +void *operator new(size_t size, const std::nothrow_t &) noexcept { return sead::system::NewImpl(nullptr, size, 8, false); } -void* operator new[](size_t size, const std::nothrow_t&) noexcept +void *operator new[](size_t size, const std::nothrow_t &) noexcept { return sead::system::NewImpl(nullptr, size, 8, false); } -======= ->>>>>>> d9f97d1785079d0fc96363d314c2b13c6bd6c5f2 // operator new(size_t, s32 alignment) -void* operator new(size_t size, s32 alignment) +void *operator new(size_t size, s32 alignment) { return sead::system::NewImpl(nullptr, size, alignment, true); } -void* operator new[](size_t size, s32 alignment) +void *operator new[](size_t size, s32 alignment) { return sead::system::NewImpl(nullptr, size, alignment, true); } -<<<<<<< HEAD -void* operator new(size_t size, s32 alignment, const std::nothrow_t&) noexcept +void *operator new(size_t size, s32 alignment, const std::nothrow_t &) noexcept { return sead::system::NewImpl(nullptr, size, alignment, false); } -void* operator new[](size_t size, s32 alignment, const std::nothrow_t&) noexcept +void *operator new[](size_t size, s32 alignment, const std::nothrow_t &) noexcept { return sead::system::NewImpl(nullptr, size, alignment, false); } -======= ->>>>>>> d9f97d1785079d0fc96363d314c2b13c6bd6c5f2 // operator new(size_t, sead::Heap*, s32 alignment) -void* operator new(size_t size, sead::Heap* heap, s32 alignment) +void *operator new(size_t size, sead::Heap *heap, s32 alignment) { return sead::system::NewImpl(heap, size, alignment, true); } -void* operator new[](size_t size, sead::Heap* heap, s32 alignment) +void *operator new[](size_t size, sead::Heap *heap, s32 alignment) { return sead::system::NewImpl(heap, size, alignment, true); } -<<<<<<< HEAD -void* operator new(size_t size, sead::Heap* heap, s32 alignment, const std::nothrow_t&) noexcept +void *operator new(size_t size, sead::Heap *heap, s32 alignment, const std::nothrow_t &) noexcept { return sead::system::NewImpl(heap, size, alignment, false); } -void* operator new[](size_t size, sead::Heap* heap, s32 alignment, const std::nothrow_t&) noexcept +void *operator new[](size_t size, sead::Heap *heap, s32 alignment, const std::nothrow_t &) noexcept { return sead::system::NewImpl(heap, size, alignment, false); } // operator new(size_t, sead::Heap*, const std::nothrow_t&) -void* operator new(size_t size, sead::Heap* heap, const std::nothrow_t&) noexcept +void *operator new(size_t size, sead::Heap *heap, const std::nothrow_t &) noexcept { return sead::system::NewImpl(heap, size, 8, false); } -void* operator new[](size_t size, sead::Heap* heap, const std::nothrow_t&) noexcept +void *operator new[](size_t size, sead::Heap *heap, const std::nothrow_t &) noexcept { return sead::system::NewImpl(heap, size, 8, false); } -======= -// operator new(size_t, sead::Heap*, const std::nothrow_t&) - ->>>>>>> d9f97d1785079d0fc96363d314c2b13c6bd6c5f2 // operator delete(void*) -void operator delete(void* ptr) noexcept +void operator delete(void *ptr) noexcept { sead::system::DeleteImpl(ptr); } -void operator delete[](void* ptr) noexcept +void operator delete[](void *ptr) noexcept { sead::system::DeleteImpl(ptr); } -<<<<<<< HEAD -void operator delete(void* ptr, const std::nothrow_t&) noexcept +void operator delete(void *ptr, const std::nothrow_t &) noexcept { sead::system::DeleteImpl(ptr); } -void operator delete[](void* ptr, const std::nothrow_t&) noexcept +void operator delete[](void *ptr, const std::nothrow_t &) noexcept { sead::system::DeleteImpl(ptr); } -======= ->>>>>>> d9f97d1785079d0fc96363d314c2b13c6bd6c5f2 // operator delete(void*, s32) -void operator delete(void* ptr, s32) +void operator delete(void *ptr, s32) { sead::system::DeleteImpl(ptr); } -void operator delete[](void* ptr, s32) +void operator delete[](void *ptr, s32) { sead::system::DeleteImpl(ptr); } -<<<<<<< HEAD -void operator delete(void* ptr, s32, const std::nothrow_t&) noexcept +void operator delete(void *ptr, s32, const std::nothrow_t &) noexcept { sead::system::DeleteImpl(ptr); } -void operator delete[](void* ptr, s32, const std::nothrow_t&) noexcept +void operator delete[](void *ptr, s32, const std::nothrow_t &) noexcept { sead::system::DeleteImpl(ptr); } // operator delete(void*, sead::Heap*, const std::nothrow_t&) -void operator delete(void* ptr, sead::Heap*, const std::nothrow_t&) noexcept +void operator delete(void *ptr, sead::Heap *, const std::nothrow_t &) noexcept { sead::system::DeleteImpl(ptr); } -void operator delete[](void* ptr, sead::Heap*, const std::nothrow_t&) noexcept +void operator delete[](void *ptr, sead::Heap *, const std::nothrow_t &) noexcept { sead::system::DeleteImpl(ptr); } -======= -// operator delete(void*, sead::Heap*, const std::nothrow_t&) - ->>>>>>> d9f97d1785079d0fc96363d314c2b13c6bd6c5f2 // operator delete(void*, sead::Heap*, s32) -void operator delete(void* ptr, sead::Heap*, s32) +void operator delete(void *ptr, sead::Heap *, s32) { sead::system::DeleteImpl(ptr); } -void operator delete[](void* ptr, sead::Heap*, s32) -{ - sead::system::DeleteImpl(ptr); -<<<<<<< HEAD -} - -void operator delete(void* ptr, sead::Heap*, s32, const std::nothrow_t&) noexcept +void operator delete[](void *ptr, sead::Heap *, s32) { sead::system::DeleteImpl(ptr); } -void operator delete[](void* ptr, sead::Heap*, s32, const std::nothrow_t&) noexcept +void operator delete(void *ptr, sead::Heap *, s32, const std::nothrow_t &) noexcept +{ + sead::system::DeleteImpl(ptr); +} + +void operator delete[](void *ptr, sead::Heap *, s32, const std::nothrow_t &) noexcept { sead::system::DeleteImpl(ptr); -======= ->>>>>>> d9f97d1785079d0fc96363d314c2b13c6bd6c5f2 } \ No newline at end of file