summaryrefslogtreecommitdiff
path: root/src/bonusRoom.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/bonusRoom.cpp')
-rw-r--r--src/bonusRoom.cpp708
1 files changed, 708 insertions, 0 deletions
diff --git a/src/bonusRoom.cpp b/src/bonusRoom.cpp
new file mode 100644
index 0000000..6b61f27
--- /dev/null
+++ b/src/bonusRoom.cpp
@@ -0,0 +1,708 @@
+#include <common.h>
+#include <game.h>
+#include <g3dhax.h>
+#include <sfx.h>
+#include <stage.h>
+
+extern "C" bool SpawnEffect(const char*, int, Vec*, S16Vec*, Vec*);
+extern "C" void *PlaySound(dStageActor_c *, int soundID);
+extern "C" void *PlaySoundAsync(dStageActor_c *, int soundID);
+extern "C" void *StopBGMMusic();
+extern "C" void *StartBGMMusic();
+
+int Songs[2][4][15][2] = {
+
+ { // Song 1 -
+ {{3,0},{3,15},{3,45},{1,75},{3,90},{5,120},{0,0}}, // First number is the note, Second is timing: 30 is one quarter note at 120 bpm, 0,0 ends the sequence
+ {{8,0},{5,22},{3,45},{6,67},{7,82},{6,97},{6,105},{0,0}},
+ {{1,0},{1,7},{1,22},{1,37},{2,45},{3,60},{1,67},{7,82},{6,90},{0,0}},
+ {{1,0},{1,7},{1,22},{1,37},{2,45},{3,52},{0,0}}
+ },
+
+ { // Song 2 -
+ {{1,30},{2,60},{3,90},{4,120}},
+ {},
+ {},
+ {}
+ }
+
+};
+
+
+const char* Prizes[10][4] = {
+ { "I_kinoko", "g3d/I_kinoko.brres", "I_kinoko", "wait2" },
+ { "I_fireflower", "g3d/I_fireflower.brres", "I_fireflower", "wait2" },
+ { "I_iceflower", "g3d/I_iceflower.brres", "I_iceflower", "wait2" },
+ { "I_penguin", "g3d/I_penguin.brres", "I_penguin", "wait2" },
+ { "I_propeller", "g3d/I_propeller_model.brres", "I_propeller_model", "wait2" },
+ { "I_kinoko_bundle","g3d/I_mini_kinoko.brres", "I_mini_kinoko", "wait2" },
+ { "I_hammer", "g3d/I_hammer.brres", "I_hammer", "wait2" },
+ { "I_star", "g3d/I_star.brres", "I_star", "wait2" },
+ { "I_kinoko_bundle","g3d/I_life_kinoko.brres", "I_life_kinoko", "wait2" },
+ { "obj_coin", "g3d/obj_coin.brres", "obj_coin", "wait2" }
+};
+
+int PrizePacks[2][4] = { // Numbers list prizes for each level
+ // 0 = Mushroom
+ // 1 = Fireflower
+ // 2 = Iceflower
+ // 3 = Penguin
+ // 4 = Propeller
+ // 5 = MiniShroom
+ // 6 = Starman
+ // 7 = Hammer
+ // 8 = 1-ups
+ // 9 = Coins
+
+ {9, 0, 8, 1},
+ {0, 0, 8, 5}
+};
+
+int Notes[9] = {
+ SE_EMY_PATAMET_STEP,
+ SE_EMY_PATAMET_STEP_2,
+ SE_EMY_PATAMET_STEP_3,
+ SE_EMY_PATAMET_STEP_4,
+ SE_EMY_PATAMET_STEP_5,
+ SE_EMY_PATAMET_STEP_6,
+ SE_EMY_PATAMET_STEP_7,
+ SE_EMY_PATAMET_STEP_8,
+ SE_EMY_PATAMET_COMPLETE
+};
+
+
+
+const char* SAarcNameList [] = {
+ "obj_coin",
+ "I_hammer",
+ "I_star",
+ "light_block",
+ "light_block_color",
+ "I_kinoko_bundle",
+ NULL
+};
+
+class dSongBlock;
+
+class dSingAlong : public dStageActor_c {
+ public:
+ static dSingAlong *instance;
+ static dSingAlong *build();
+
+ void RegisterNote(int note);
+ void addPowerups();
+
+ int onCreate();
+ int onDelete();
+ int onExecute();
+ int onDraw();
+
+ int beforeExecute() { return true; }
+ int afterExecute(int) { return true; }
+
+ dSingAlong() : state(this, &StateID_Intro) { }
+
+ mHeapAllocator_c allocator;
+ nw4r::g3d::ResFile resFile[4];
+ m3d::mdl_c pModel[4];
+ m3d::anmChr_c pAnim[4];
+ Vec prizePos[4];
+ Vec prizeScale[4];
+
+ HermiteKey keysX[0x10];
+ unsigned int Xkey_count;
+ HermiteKey keysY[0x10];
+ unsigned int Ykey_count;
+ HermiteKey keysS[0x10];
+ unsigned int Skey_count;
+
+
+ dSongBlock *Cblock;
+ dSongBlock *Dblock;
+ dSongBlock *Eblock;
+ dSongBlock *Fblock;
+ dSongBlock *Gblock;
+ dSongBlock *Ablock;
+ dSongBlock *Bblock;
+
+
+ // you might get casting issues. due to C++. blah = (int (*)[15][2])BigArray; fixes it
+ // int (*song)[4][15][2];
+ // int (*prizes)[4];
+ int song;
+ int prize;
+ int chorus;
+ // int (*currentNote)[2];
+ int currentNote;
+ int endNote;
+ int timer;
+ int counter;
+ int Powerups[10];
+ int isResponding;
+
+ dStateWrapper_c<dSingAlong> state;
+
+ // Intro, Call, Response, Display Prize, Failure, Win, Collect Prizes
+ USING_STATES(dSingAlong);
+ DECLARE_STATE(Intro);
+ DECLARE_STATE(Call);
+ DECLARE_STATE(Response);
+ DECLARE_STATE(Prize);
+ DECLARE_STATE(Failure);
+ DECLARE_STATE(Win);
+};
+
+dSingAlong *dSingAlong::instance = 0;
+dSingAlong *dSingAlong::build() {
+ OSReport("Building Sing Along.");
+ void *buffer = AllocFromGameHeap1(sizeof(dSingAlong));
+ dSingAlong *c = new(buffer) dSingAlong;
+
+ instance = c;
+ return c;
+}
+
+
+/*****************************************************************************/
+// Events
+int dSingAlong::onCreate() {
+
+ OSReport("Creating the Sing Along gang.");
+ // Load in the settings
+ // this->song = Songs;
+ this->song = this->settings & 0xF;
+ // this->prizes = PrizePacks;
+ this->prize = (this->settings >> 4) & 0xF;
+ this->chorus = -1;
+ // this->currentNote = song[chorus][0];
+ this->currentNote = 0;
+
+ this->Powerups[0] = 0; // Mushroom
+ this->Powerups[1] = 0; // Fireflower
+ this->Powerups[2] = 0; // Iceflower
+ this->Powerups[3] = 0; // Penguin
+ this->Powerups[4] = 0; // Propeller
+ this->Powerups[5] = 0; // MiniShroom
+ this->Powerups[6] = 0; // Starman
+ this->Powerups[7] = 0; // Hammer
+ this->Powerups[8] = 0; // 1-ups
+ this->Powerups[9] = 0; // Coins
+
+ // Load in the prize models
+ allocator.link(-1, GameHeaps[0], 0, 0x20);
+
+ int p;
+ nw4r::g3d::ResMdl mdl;
+ nw4r::g3d::ResAnmChr anmChr;
+
+ for (int i = 0; i < 4; i++) {
+ p = PrizePacks[prize][i];
+
+ // nw4r::g3d::ResFile file;
+ // resFile[i] = file;
+ // m3d::mdl_c model;
+ // pModel[i] = model;
+ // m3d::anmChr_c anim;
+ // pAnim[i] = anim;
+
+ OSReport("Model %d: %s, %s, %s", i, Prizes[p][0], Prizes[p][1], Prizes[p][2]);
+ resFile[i].data = getResource(Prizes[p][0], Prizes[p][1]);
+ mdl = resFile[i].GetResMdl(Prizes[p][2]);
+ pModel[i].setup(mdl, &allocator, 0x224, 1, 0);
+ SetupTextures_Item(&pModel[i], 0); // 800B43D0
+
+ anmChr = resFile[i].GetResAnmChr("wait2");
+ pAnim[i].setup(mdl, anmChr, &allocator, 0);
+ // pAnim[i].bind(&pModel[i], anmChr, 1);
+ // pModel[i].bindAnim(&pAnim[i], 0.0);
+ pAnim[i].setUpdateRate(1.0);
+
+ prizePos[i] = (Vec){ pos.x, pos.y, pos.z };
+ prizeScale[i] = (Vec){ 5.0, 5.0, 5.0 };
+ }
+
+ allocator.unlink();
+
+ // Create and prepare the blocks
+ float x = pos.x;
+ float y = pos.y - 40.0;
+ float z = pos.z;
+ S16Vec rot = (S16Vec){0,0,0};
+
+ Cblock = (dSongBlock*)create(WM_KILLER, 1, &(Vec){x-96.0, y, z}, &rot, 0);
+ Dblock = (dSongBlock*)create(WM_KILLER, 2, &(Vec){x-64.0, y, z}, &rot, 0);
+ Eblock = (dSongBlock*)create(WM_KILLER, 3, &(Vec){x-32.0, y, z}, &rot, 0);
+ Fblock = (dSongBlock*)create(WM_KILLER, 4, &(Vec){x , y, z}, &rot, 0);
+ Gblock = (dSongBlock*)create(WM_KILLER, 5, &(Vec){x+32.0, y, z}, &rot, 0);
+ Ablock = (dSongBlock*)create(WM_KILLER, 6, &(Vec){x+64.0, y, z}, &rot, 0);
+ Bblock = (dSongBlock*)create(WM_KILLER, 7, &(Vec){x+96.0, y, z}, &rot, 0);
+
+ // // Trigger the intro state
+ // state.setState(&StateID_Intro);
+
+ isResponding = 0;
+ OSReport("Is now responding: %d", isResponding);
+ OSReport("Daddy is at: %x", this);
+
+ return true;
+}
+
+int dSingAlong::onExecute() {
+ state.execute();
+
+ return true;
+}
+
+int dSingAlong::onDraw() {
+
+ if (chorus == -1) { return true; }
+
+ for (int i = 0; i < (chorus + 1); i++) {
+ matrix.translation(prizePos[i].x, prizePos[i].y, prizePos[i].z);
+ matrix.applyRotationYXZ(&rot.x, &rot.y, &rot.z);
+
+ pModel[i].setDrawMatrix(matrix);
+
+ pModel[i].setScale(&prizeScale[i]);
+
+ // OSReport("Calc World");
+ // pModel[i].calcWorld(false);
+
+ // OSReport("Schedule");
+ // pModel[i].scheduleForDrawing();
+
+ // if (pAnim[i].isAnimationDone()) {
+ // pAnim[i].setCurrentFrame(0.0); }
+
+ // OSReport("vf1C");
+ // pModel[i]._vf1C();
+ }
+
+ return true;
+}
+
+int dSingAlong::onDelete() {
+ return 1;
+}
+
+/*****************************************************************************/
+// Register a Note being played by the players
+void dSingAlong::RegisterNote(int note) {
+ OSReport("Register Note begins: %d", note);
+ OSReport("Responding is: %d", isResponding);
+
+ if (isResponding == 1) {
+ OSReport("State was checked");
+
+ if (note == Songs[song][chorus][currentNote][0]) {
+ OSReport("Note was correct");
+
+ currentNote += 1;
+ }
+ else {
+ OSReport("Player failed");
+ isResponding = 0;
+ state.setState(&StateID_Failure);
+ }
+ }
+}
+
+
+// Game Flow
+//
+// 1) Intro, maybe a banner 'Match the music'
+// 2) Present the prize
+// 3) Play the music
+// 4) Wait for responses
+// 6) If failure, make prize disappear, award banked prizes, end stage, play failure music
+// 7) If successful, place the prize in the bank, and proceed to step 3 on the next segment
+// 8) If all things are successful, play the victory theme and award the banked prizes, end stage
+
+
+/*****************************************************************************/
+// Intro
+CREATE_STATE(dSingAlong, Intro);
+
+void dSingAlong::executeState_Intro() {
+ state.setState(&StateID_Prize);
+}
+
+//*****************************************************************************/
+// Prize
+CREATE_STATE(dSingAlong, Prize);
+
+void dSingAlong::beginState_Prize() {
+ this->timer = 0;
+
+ if (chorus != 0) {
+ this->timer = 120;
+ }
+
+ Xkey_count = 2;
+ Ykey_count = 2;
+ Skey_count = 2;
+
+ // /* keysX[i] = { frame, value, slope }; */
+ keysX[0] = (HermiteKey){ 0.0, pos.x, 0.8 };
+ keysY[0] = (HermiteKey){ 0.0, pos.y, 0.8 };
+ keysS[0] = (HermiteKey){ 0.0, 5.0, 0.8 };
+
+ keysX[1] = (HermiteKey){ 60.0, pos.x + (30.0 * (chorus + 1)) - 320.0, 0.8 };
+ keysY[1] = (HermiteKey){ 60.0, pos.y - 80.0, 0.8 };
+ keysS[1] = (HermiteKey){ 60.0, 1.0, 0.8 };
+}
+void dSingAlong::executeState_Prize() {
+
+ if (timer == 120) { // Play a nice success sound, and wait a second
+ PlaySound(this, SE_MG_IH_PAIR_OK); // SE_MG_IH_NICE or SE_MG_UH_NICE
+
+ int p;
+ p = PrizePacks[prize][chorus];
+ this->Powerups[p] += 1;
+ }
+
+ if (timer < 60 && timer >= 0) { // Move last time's model to the corner.
+ float modX = GetHermiteCurveValue(60.0 - timer, keysX, Xkey_count);
+ float modY = GetHermiteCurveValue(60.0 - timer, keysY, Ykey_count);
+ float modS = GetHermiteCurveValue(60.0 - timer, keysS, Skey_count);
+
+
+ prizePos[chorus] = (Vec){ modX, modY, prizePos[chorus].z };
+ prizeScale[chorus] = (Vec){ modS, modS, modS };
+ }
+
+ if (timer == 0) {
+ chorus += 1;
+
+ SpawnEffect("Wm_en_blockcloud", 0, &(Vec){pos.x, pos.y, pos.z+500.0}, &(S16Vec){0,0,0}, &(Vec){1.5, 1.5, 1.5});
+ PlaySound(this, SE_OBJ_ITEM_APPEAR); // SE_OBJ_GOOD_ITEM_APPEAR
+ }
+
+ if (timer == -90) {
+ state.setState(&StateID_Call);
+ }
+
+ timer -= 1;
+}
+
+//*****************************************************************************/
+// Call
+CREATE_STATE(dSingAlong, Call);
+
+void dSingAlong::beginState_Call() {
+ timer = 0;
+ currentNote = 0;
+
+ OSReport("SONG: {%d, %d} {%d %d} {%d %d}", Songs[song][chorus][0][0], Songs[song][chorus][0][1], Songs[song][chorus][1][0], Songs[song][chorus][1][1], Songs[song][chorus][2][0], Songs[song][chorus][2][1]);
+}
+void dSingAlong::executeState_Call() {
+
+ // OSReport("%d: Waiting for timer %d", timer, *currentNote[1]);
+
+ if (timer == Songs[song][chorus][currentNote][1]) {
+ OSReport("Playing Note %d", Songs[song][chorus][currentNote][0]);
+
+ // int play = Notes[Songs[song][chorus][currentNote][0]-1];
+
+ // if ((currentNote > 1) &&
+ // (Notes[Songs[song][chorus][currentNote][0]-1] == Notes[Songs[song][chorus][currentNote-1][0]-1]) &&
+ // (Notes[Songs[song][chorus][currentNote][0]-1] == Notes[Songs[song][chorus][currentNote-2][0]-1]))
+ // {
+ // SoundPlayingClass::instance3->PlaySoundAtPosition(play, &(Vec2){pos.x,pos.y}, 0);
+ // }
+
+ // else if ((currentNote > 0) && (Notes[Songs[song][chorus][currentNote][0]-1] == Notes[Songs[song][chorus][currentNote-1][0]-1])) {
+ // SoundPlayingClass::instance2->PlaySoundAtPosition(play, &(Vec2){pos.x,pos.y}, 0);
+ // }
+ // else {
+ // SoundPlayingClass::instance1->PlaySoundAtPosition(play, &(Vec2){pos.x,pos.y}, 0);
+ // }
+
+ SoundPlayingClass::instance1->PlaySoundAtPosition(Notes[Songs[song][chorus][currentNote][0]-1], &(Vec2){pos.x,pos.y}, 0);
+
+ // PlaySoundAsync(this, Notes[Songs[song][chorus][currentNote][0]-1]);
+
+
+
+ currentNote += 1;
+ // currentNote = song[chorus][counter];
+ OSReport("Next Note %d", Songs[song][chorus][currentNote][0]);
+
+ if (Songs[song][chorus][currentNote][0] == 0) {
+ OSReport("Switching to Response Mode");
+ state.setState(&StateID_Response);
+ }
+ }
+
+ timer += 1;
+}
+
+/*****************************************************************************/
+// Response
+CREATE_STATE(dSingAlong, Response);
+
+void dSingAlong::beginState_Response() {
+ timer = 0;
+ currentNote = 0;
+ isResponding = 1;
+ OSReport("Is now responding: %d", isResponding);
+}
+void dSingAlong::executeState_Response() {
+ if (Songs[song][chorus][currentNote][0] == 0) {
+ isResponding = 0;
+ OSReport("Switching to some other mode: %d", isResponding);
+ if (chorus == 3) {
+ state.setState(&StateID_Win);
+ }
+ else {
+ state.setState(&StateID_Prize);
+ }
+ }
+}
+
+/*****************************************************************************/
+// Failure
+CREATE_STATE(dSingAlong, Failure);
+
+void dSingAlong::beginState_Failure() {
+ this->timer = 0;
+
+ PlaySound(this, SE_MG_CMN_WIN_CLOSE);
+}
+void dSingAlong::executeState_Failure() {
+ if (timer == 240) {
+ this->addPowerups();
+ ExitStage(3, 0, 0, 4);
+ }
+ timer += 1;
+}
+
+/*****************************************************************************/
+// Win
+CREATE_STATE(dSingAlong, Win);
+
+void dSingAlong::beginState_Win() {
+ this->timer = 0;
+
+ PlaySound(this, SE_MG_CMN_FANFARE_GREAT);
+}
+void dSingAlong::executeState_Win() {
+ if (timer == 240) {
+ this->addPowerups();
+ ExitStage(3, 0, 0, 4);
+ }
+ timer += 1;
+}
+
+/*****************************************************************************/
+// Add Powerups at the End of the Stage
+void dSingAlong::addPowerups() {
+ SaveFile *file = GetSaveFile();
+ SaveBlock *block = file->GetBlock(file->header.current_file);
+
+ for (int i = 0; i < 7; i++) { // Change this to 8 to support hammers
+
+ block->powerups_available[i] = block->powerups_available[i] + this->Powerups[i];
+
+ if (block->powerups_available[i] > 99) { block->powerups_available[i] = 99; }
+ }
+
+
+ for (int i = 0; i < 4; i++) { // Make sure all players get the reward!
+ block->player_coins[i] = (this->Powerups[9] * 50) + block->player_coins[i];
+
+ for (;block->player_coins[i] < 100; block->player_coins[i] - 100) {
+ block->player_lives[i] = 1 + block->player_lives[i];
+ }
+
+ block->player_lives[i] = this->Powerups[8] + block->player_lives[i];
+ if (block->player_lives[i] > 99) { block->player_lives[i] = 99; }
+ }
+
+ return;
+}
+
+
+/*****************************************************************************/
+/*****************************************************************************/
+/*****************************************************************************/
+// Replaces: Nothing yet
+
+class dSongBlock : public daEnBlockMain_c {
+public:
+ Physics::Info physicsInfo;
+
+ int onCreate();
+ int onDelete();
+ int onExecute();
+ int onDraw();
+
+ mHeapAllocator_c allocator;
+ nw4r::g3d::ResFile resFile;
+
+ m3d::mdl_c bodyModel;
+ m3d::anmChr_c glow;
+
+ int note;
+
+ void calledWhenUpMoveExecutes();
+ void calledWhenDownMoveExecutes();
+ void blockWasHit(bool isDown);
+ USING_STATES(dSongBlock);
+ DECLARE_STATE(Wait);
+
+ static dSongBlock *build();
+};
+
+
+CREATE_STATE(dSongBlock, Wait);
+
+
+dSongBlock *dSongBlock::build() {
+ void *buffer = AllocFromGameHeap1(sizeof(dSongBlock));
+ return new(buffer) dSongBlock;
+}
+
+
+int dSongBlock::onCreate() {
+
+ // Settings
+ this->note = this->settings;
+
+ // Model creation
+ allocator.link(-1, GameHeaps[0], 0, 0x20);
+
+ this->resFile.data = getResource("light_block", "g3d/light_block.brres");
+ nw4r::g3d::ResMdl mdl = this->resFile.GetResMdl("light_block");
+ bodyModel.setup(mdl, &allocator, 0x224, 1, 0);
+ SetupTextures_MapObj(&bodyModel, 0); // 800B42B0
+
+ // Animation Assignment
+ nw4r::g3d::ResAnmChr anmChr = this->resFile.GetResAnmChr("light_block");
+ this->glow.setup(mdl, anmChr, &this->allocator, 0);
+ glow.bind(&bodyModel, anmChr, 1);
+ bodyModel.bindAnim(&glow, 0.0);
+ glow.setUpdateRate(1.0);
+ allocator.unlink();
+
+ // Block Physics
+ blockInit(pos.y);
+
+ physicsInfo.x1 = -8;
+ physicsInfo.y1 = 16;
+ physicsInfo.x2 = 8;
+ physicsInfo.y2 = 0;
+
+ physicsInfo.otherCallback1 = &daEnBlockMain_c::OPhysicsCallback1;
+ physicsInfo.otherCallback2 = &daEnBlockMain_c::OPhysicsCallback2;
+ physicsInfo.otherCallback3 = &daEnBlockMain_c::OPhysicsCallback3;
+
+ physics.setup(this, &physicsInfo, 3, currentLayerID);
+ physics.flagsMaybe = 0x260;
+ physics.callback1 = &daEnBlockMain_c::PhysicsCallback1;
+ physics.callback2 = &daEnBlockMain_c::PhysicsCallback2;
+ physics.callback3 = &daEnBlockMain_c::PhysicsCallback3;
+ physics.addToList();
+
+ // Change State
+ doStateChange(&dSongBlock::StateID_Wait);
+
+ return true;
+}
+
+
+int dSongBlock::onDelete() {
+ physics.removeFromList();
+ return true;
+}
+
+
+int dSongBlock::onExecute() {
+ acState.execute();
+ physics.update();
+ blockUpdate();
+
+ // now check zone bounds based on state
+ if (acState.getCurrentState()->isEqual(&StateID_Wait)) {
+ checkZoneBoundaries(0);
+ }
+
+ return true;
+}
+
+
+int dSongBlock::onDraw() {
+
+ // tile.x = pos.x - 8;
+ // tile.y = -(16 + pos.y);
+
+ matrix.translation(pos.x, pos.y+8.0, pos.z);
+ matrix.applyRotationYXZ(&rot.x, &rot.y, &rot.z);
+
+ bodyModel.setDrawMatrix(matrix);
+ Vec myScale = (Vec){scale.x * 0.5, scale.y * 0.5, scale.z * 0.5};
+ bodyModel.setScale(&myScale);
+ bodyModel.calcWorld(false);
+
+ bodyModel.scheduleForDrawing();
+ return true;
+}
+
+
+void dSongBlock::blockWasHit(bool isDown) {
+ pos.y = initialY;
+
+ PlaySoundAsync(this, Notes[this->note-1]);
+ // Play an effect?
+ OSReport("Note is: %d", this->note);
+ dSingAlong::instance->RegisterNote(this->note);
+ OSReport("Note successfully registered");
+
+ physics.setup(this, &physicsInfo, 3, currentLayerID);
+ physics.addToList();
+
+ doStateChange(&StateID_Wait);
+}
+
+
+void dSongBlock::calledWhenUpMoveExecutes() {
+ this->bodyModel._vf1C();
+
+ if (this->glow.isAnimationDone()) {
+ this->glow.setCurrentFrame(0.0); }
+
+ if (initialY >= pos.y)
+ blockWasHit(false);
+}
+
+void dSongBlock::calledWhenDownMoveExecutes() {
+ this->bodyModel._vf1C();
+
+ if (this->glow.isAnimationDone()) {
+ this->glow.setCurrentFrame(0.0); }
+
+ if (initialY <= pos.y)
+ blockWasHit(true);
+}
+
+
+void dSongBlock::beginState_Wait() {}
+void dSongBlock::endState_Wait() {}
+void dSongBlock::executeState_Wait() {
+ int result = blockResult();
+
+ if (result == 0)
+ return;
+
+ if (result == 1) {
+ doStateChange(&daEnBlockMain_c::StateID_UpMove);
+ anotherFlag = 2;
+ isGroundPound = false;
+ } else {
+ doStateChange(&daEnBlockMain_c::StateID_DownMove);
+ anotherFlag = 1;
+ isGroundPound = true;
+ }
+}
+
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-01 09:40:31 +0000