Water.c

// ---------------------------------------------------------------------
// RSDK Project: Sonic Mania
// Object Description: Water Object
// Object Author: Christian Whitehead/Simon Thomley/Hunter Bridges
// Decompiled by: Rubberduckycooly & RMGRich
// ---------------------------------------------------------------------

#include "Game.h"

ObjectWater *Water;

void Water_Update(void)
{
    RSDK_THIS(Water);

    StateMachine_Run(self->state);
}

void Water_LateUpdate(void) {}

void Water_StaticUpdate(void)
{
    EntityPauseMenu *pauseMenu = RSDK_GET_ENTITY(SLOT_PAUSEMENU, PauseMenu);

    if (pauseMenu->classID != PauseMenu->classID) {
        if (Water->newWaterLevel == Water->targetWaterLevel) {
            Water->moveWaterLevel = 0;

            if (Water->waterLevelVolume > 0)
                Water->waterLevelVolume--;
            Water->waterLevelVolume = CLAMP(Water->waterLevelVolume, 0, 30);
        }
        else {
            if (RSDK.CheckSceneFolder("HCZ") && Water->moveWaterLevel) {
                if (!(Water->waterLevelVolume % 5))
                    Camera_ShakeScreen(0, 0, 1);
                ++Water->waterLevelVolume;
            }

            if (Water->newWaterLevel >= Water->targetWaterLevel) {
                Water->newWaterLevel -= Water->waterMoveSpeed;
                if (Water->newWaterLevel < Water->targetWaterLevel)
                    Water->newWaterLevel = Water->targetWaterLevel;
            }
            else {
                Water->newWaterLevel += Water->waterMoveSpeed;
                if (Water->newWaterLevel > Water->targetWaterLevel)
                    Water->newWaterLevel = Water->targetWaterLevel;
            }
        }
    }

    if (Water->playingWaterLevelSfx) {
        if (Water->waterLevelVolume > 30)
            Water->waterLevelVolume = 30;
        float volume = Water->waterLevelVolume / 30.0;
        RSDK.SetChannelAttributes(Water->waterLevelChannelL, volume, -1.0, 1.0);
        RSDK.SetChannelAttributes(Water->waterLevelChannelR, volume, 1.0, 1.0);
    }

    if (Water->waterLevelVolume > 0) {
        if (!Water->playingWaterLevelSfx) {
            Water->waterLevelChannelL = RSDK.PlaySfx(Water->sfxWaterLevelL, 1, 255);
            RSDK.SetChannelAttributes(Water->waterLevelChannelL, 0.0, -1.0, 1.0);

            Water->waterLevelChannelR = RSDK.PlaySfx(Water->sfxWaterLevelR, 1, 255);
            RSDK.SetChannelAttributes(Water->waterLevelChannelR, 0.0, 1.0, 1.0);

            Water->playingWaterLevelSfx = true;
        }
    }
    else if (!Water->waterLevelVolume && Water->playingWaterLevelSfx) {
        RSDK.StopSfx(Water->sfxWaterLevelL);
        RSDK.StopSfx(Water->sfxWaterLevelR);
        Water->playingWaterLevelSfx = false;
    }

    bool32 wakeActive = false;
    for (int32 i = 0; i < PLAYER_COUNT; ++i) wakeActive |= Water->wakePosX[i] > 0;

    if (wakeActive) {
        if (pauseMenu->classID != PauseMenu->classID)
            RSDK.ProcessAnimation(&Water->wakeAnimator);

        if (!Water->playingSkimSfx) {
            RSDK.PlaySfx(Water->sfxSkim, 3570, 0xFF);
            Water->playingSkimSfx = true;
        }
    }
    else if (Water->playingSkimSfx) {
        RSDK.StopSfx(Water->sfxSkim);
        Water->playingSkimSfx = false;
    }
}

void Water_Draw(void)
{
    RSDK_THIS(Water);

    StateMachine_Run(self->stateDraw);
}

void Water_Create(void *data)
{
    RSDK_THIS(Water);

    self->visible = true;
    if (!SceneInfo->inEditor) {
        if (data)
            self->type = VOID_TO_INT(data);

        switch (self->type) {
            case WATER_WATERLEVEL:
                if (globals->gameMode == MODE_COMPETITION && RSDK.CheckSceneFolder("CPZ")) {
                    destroyEntity(self);
                }
                else {
                    self->active    = ACTIVE_NORMAL;
                    self->inkEffect = INK_ADD;
                    self->drawGroup = Zone->hudDrawGroup - 1;
                    self->alpha     = RSDK.CheckSceneFolder("AIZ") ? 0x60 : 0xE0;
                    RSDK.SetSpriteAnimation(Water->aniFrames, 0, &self->animator, true, 0);
                    self->state     = Water_State_Water;
                    self->stateDraw = Water_Draw_Water;
                    self->size.x >>= 16;
                    Water->newWaterLevel    = self->position.y;
                    Water->targetWaterLevel = self->position.y;
                }
                break;

            case WATER_POOL:
                self->active = ACTIVE_BOUNDS;
                self->drawFX = FX_FLIP;
                switch (self->priority) {
                    case WATER_PRIORITY_LOWEST: self->drawGroup = Zone->objectDrawGroup[0] - 1; break;
                    case WATER_PRIORITY_LOW: self->drawGroup = Zone->playerDrawGroup[0]; break;
                    case WATER_PRIORITY_HIGH: self->drawGroup = Zone->playerDrawGroup[1]; break;
                    case WATER_PRIORITY_HIGHEST: self->drawGroup = Zone->hudDrawGroup - 1; break;
                    default: break;
                }

                self->updateRange.x = self->size.x >> 1;
                self->updateRange.y = self->size.y >> 1;

                self->hitbox.right  = (self->size.x >> 17);
                self->hitbox.left   = -(self->size.x >> 17);
                self->hitbox.bottom = (self->size.y >> 17);
                self->hitbox.top    = -(self->size.y >> 17);

                self->state     = Water_State_Pool;
                self->stateDraw = Water_Draw_Pool;
                break;

            case WATER_BUBBLER:
            case WATER_BIG_BUBBLER:
                self->drawGroup     = Zone->objectDrawGroup[0];
                self->inkEffect     = INK_ADD;
                self->alpha         = 0x100;
                self->active        = ACTIVE_BOUNDS;
                self->updateRange.x = TO_FIXED(16);
                self->updateRange.y = TO_FIXED(16);

                RSDK.SetSpriteAnimation(Water->aniFrames, 2, &self->animator, true, 0);

                self->state     = Water_State_Bubbler;
                self->stateDraw = Water_Draw_Bubbler;
                break;

            case WATER_HEIGHT_TRIGGER:
                self->active  = ACTIVE_BOUNDS;
                self->visible = false;
                if (self->buttonTag > 0) {
                    self->active = ACTIVE_NORMAL;
                    Water_SetupTagLink();
                }

                self->updateRange.x = self->size.x >> 1;
                self->updateRange.y = self->size.y >> 1;

                self->state = Water_State_HeightTrigger;
                break;

            case WATER_BTN_BIG_BUBBLE:
                self->drawGroup     = Zone->objectDrawGroup[0];
                self->active        = ACTIVE_BOUNDS;
                self->updateRange.x = TO_FIXED(16);
                self->updateRange.y = TO_FIXED(16);

                self->state     = Water_State_BtnBigBubble;
                self->stateDraw = StateMachine_None;

                Water_SetupTagLink();
                break;

            case WATER_SPLASH:
                self->active    = ACTIVE_NORMAL;
                self->drawGroup = Zone->hudDrawGroup - 2;
                RSDK.SetSpriteAnimation(Water->aniFrames, 1, &self->animator, true, 0);

                self->state     = Water_State_Splash;
                self->stateDraw = Water_Draw_Splash;
                break;

            case WATER_BUBBLE:
                self->active        = ACTIVE_NORMAL;
                self->drawGroup     = Zone->playerDrawGroup[1];
                self->drawFX        = FX_SCALE;
                self->inkEffect     = INK_ADD;
                self->alpha         = 0x100;
                self->updateRange.x = TO_FIXED(128);
                self->updateRange.y = TO_FIXED(128);
                self->isPermanent   = true;

                self->scale.x = 0x200;
                self->scale.y = 0x200;
                RSDK.SetSpriteAnimation(Water->aniFrames, 5, &self->animator, true, 0);

                self->state     = Water_State_Bubble;
                self->stateDraw = Water_Draw_Bubble;
                break;

            case WATER_COUNTDOWN:
                self->active        = ACTIVE_NORMAL;
                self->drawGroup     = Zone->playerDrawGroup[1];
                self->drawFX        = FX_SCALE;
                self->inkEffect     = INK_ADD;
                self->alpha         = 0x100;
                self->updateRange.x = TO_FIXED(128);
                self->updateRange.y = TO_FIXED(128);

                self->scale.x = 0x200;
                self->scale.y = 0x200;
                RSDK.SetSpriteAnimation(Water->aniFrames, 7, &self->animator, true, 0);

                self->state     = Water_State_Countdown;
                self->stateDraw = Water_Draw_Countdown;
                break;

            default: break;
        }
    }
}

void Water_StageLoad(void)
{
    Water->active = ACTIVE_ALWAYS;

    Water->aniFrames = RSDK.LoadSpriteAnimation("Global/Water.bin", SCOPE_STAGE);

    Water->waterLevel       = 0x7FFFFFFF;
    Water->newWaterLevel    = Water->waterLevel;
    Water->targetWaterLevel = Water->waterLevel;

    Water->disableWaterSplash = false;

    Water->hitboxPlayerBubble.left   = -2;
    Water->hitboxPlayerBubble.top    = -2;
    Water->hitboxPlayerBubble.right  = 2;
    Water->hitboxPlayerBubble.bottom = 2;

    Water->hitboxPoint.left   = -1;
    Water->hitboxPoint.top    = -1;
    Water->hitboxPoint.right  = 1;
    Water->hitboxPoint.bottom = 1;

    Water->sfxSplash     = RSDK.GetSfx("Stage/Splash.wav");
    Water->sfxBreathe    = RSDK.GetSfx("Stage/Breathe.wav");
    Water->sfxWarning    = RSDK.GetSfx("Stage/Warning.wav");
    Water->sfxDrown      = RSDK.GetSfx("Stage/Drown.wav");
    Water->sfxDrownAlert = RSDK.GetSfx("Stage/DrownAlert.wav");
    Water->sfxSkim       = RSDK.GetSfx("HCZ/Skim.wav");

    if (RSDK.CheckSceneFolder("HCZ")) {
        Water->wakeFrames      = RSDK.LoadSpriteAnimation("HCZ/Wake.bin", SCOPE_STAGE);
        Water->bigBubbleFrames = RSDK.LoadSpriteAnimation("HCZ/BigBubble.bin", SCOPE_STAGE);

        Water->sfxWaterLevelL = RSDK.GetSfx("HCZ/WaterLevel_L.wav");
        Water->sfxWaterLevelR = RSDK.GetSfx("HCZ/WaterLevel_R.wav");
        Water->sfxDNAGrab     = RSDK.GetSfx("CPZ/DNAGrab.wav");
        Water->sfxDNABurst    = RSDK.GetSfx("CPZ/DNABurst.wav");

        RSDK.SetSpriteAnimation(Water->wakeFrames, 0, &Water->wakeAnimator, true, 0);
    }
}

void Water_DrawHook_ApplyWaterPalette(void)
{
    RSDKScreenInfo *screen = &ScreenInfo[SceneInfo->currentScreenID];
    int32 waterDrawPos     = CLAMP(FROM_FIXED(Water->waterLevel) - screen->position.y, 0, screen->size.y);

    RSDK.SetActivePalette(Water->waterPalette, waterDrawPos, screen->size.y);
    ScreenInfo[SceneInfo->currentScreenID].waterDrawPos = waterDrawPos;
}

void Water_DrawHook_RemoveWaterPalette(void) { RSDK.SetActivePalette(0, 0, ScreenInfo[SceneInfo->currentScreenID].size.y); }

void Water_SetupTagLink(void)
{
    RSDK_THIS(Water);

    self->taggedButton = NULL;
    if (self->buttonTag > 0) {
        if (Button) {
            foreach_all(Button, button)
            {
                if (button->tag == self->buttonTag) {
                    self->taggedButton = button;
                    foreach_break;
                }
            }
        }

        if (PullChain && !self->taggedButton) {
            foreach_all(PullChain, chain)
            {
                if (chain->tag == self->buttonTag) {
                    self->taggedButton = (EntityButton *)chain;
                    foreach_break;
                }
            }
        }

        if (self->taggedButton) {
            if (self->updateRange.x < TO_FIXED(128) + abs(self->position.x - self->taggedButton->position.x))
                self->updateRange.x = TO_FIXED(128) + abs(self->position.x - self->taggedButton->position.x);

            if (self->updateRange.y < TO_FIXED(128) + abs(self->position.y - self->taggedButton->position.y))
                self->updateRange.y = TO_FIXED(128) + abs(self->position.y - self->taggedButton->position.y);
        }
    }
}

void Water_SpawnBubble(EntityPlayer *player, int32 id)
{
    if (Water->constBubbleTimer[id] <= 0) {
        Water->constBubbleTimer[id] = 60;
        if (RSDK.Rand(0, 3) == 1)
            Water->randBubbleTimer[id] = RSDK.Rand(0, 16) + 8;
        else
            Water->randBubbleTimer[id] = 0x200;
    }
    else {
        Water->constBubbleTimer[id]--;
        if (Water->randBubbleTimer[id] <= 0)
            Water->randBubbleTimer[id] = 0x200;
        else
            return;
    }

    EntityWater *bubble = CREATE_ENTITY(Water, INT_TO_VOID(WATER_BUBBLE), player->position.x, player->position.y);
    if (player->direction) {
        bubble->position.x -= TO_FIXED(6);
        bubble->angle = 0x100;
    }
    else {
        bubble->position.x += TO_FIXED(6);
    }

    bubble->childPtr   = player;
    bubble->bubbleX    = bubble->position.x;
    bubble->velocity.y = -0x8800;
    bubble->drawGroup  = player->drawGroup + 1;
}

void Water_SpawnCountDownBubble(EntityPlayer *player, int32 id, uint8 bubbleID)
{
    EntityWater *bubble = CREATE_ENTITY(Water, INT_TO_VOID(WATER_COUNTDOWN), player->position.x, player->position.y);
    if (player->direction) {
        bubble->position.x -= TO_FIXED(6);
        bubble->angle = 0x100;
    }
    else {
        bubble->position.x += TO_FIXED(6);
    }
    bubble->bubbleX     = bubble->position.x;
    bubble->velocity.y  = -0x8800;
    bubble->childPtr    = player;
    bubble->countdownID = bubbleID;
    bubble->drawGroup   = Zone->playerDrawGroup[1] + 1;
}

void Water_State_Water(void)
{
    RSDK_THIS(Water);

    RSDK.ProcessAnimation(&self->animator);

    if (self->type == WATER_WATERLEVEL)
        Water->waterLevel = (self->size.x * RSDK.Sin512(2 * Zone->timer)) + Water->newWaterLevel;

    for (int32 playerID = 0; playerID < Player->playerCount; ++playerID) {
        EntityPlayer *player = RSDK_GET_ENTITY(playerID, Player);

        if (player->state == Player_State_FlyToPlayer && player->abilityPtrs[0]) {
            player->position.x = ((Entity *)player->abilityPtrs[0])->position.x;
            player->position.y = ((Entity *)player->abilityPtrs[0])->position.y;
        }

        Water->wakePosX[playerID] = 0;

        bool32 canEnterWater = true;
        if (!Player_CheckValidState(player) || player->state == Player_State_TransportTube) {
            if (player->state != Player_State_FlyToPlayer)
                canEnterWater = false;
        }

        if (canEnterWater) {
            EntityWater *currentPool = NULL;
            uint16 underwater        = 0;
            foreach_active(Water, pool)
            {
                if (pool->type == WATER_POOL) {
                    if (RSDK.CheckObjectCollisionTouchBox(pool, &pool->hitbox, player, &Water->hitboxPoint)) {
                        currentPool    = pool;
                        pool->childPtr = player;
                        underwater     = RSDK.GetEntitySlot(pool);
                    }
                    else if (pool->childPtr == player) {
                        pool->childPtr = NULL;
                        if (!currentPool)
                            currentPool = pool;
                    }
                }
            }

            if (player->position.y > Water->waterLevel)
                underwater = true;

            if (!Player_CheckValidState(player)) {
                if (player->state != Player_State_FlyToPlayer)
                    underwater = false;
            }

            int32 waterID = 0;
#if MANIA_USE_PLUS
            if (!player->isGhost)
#endif
                waterID = underwater;

            if (!waterID) {
                if (player->underwater) {
                    EntityWater *waterSection = NULL;
                    if (player->underwater > 1)
                        waterSection = RSDK_GET_ENTITY(player->underwater, Water);

                    player->underwater = false;
                    Player_UpdatePhysicsState(player);
                    if (player->velocity.y && (!Current || !((1 << RSDK.GetEntitySlot(player)) & Current->activePlayers))
                        && (Player_CheckValidState(player) || player->state == Player_State_FlyToPlayer)) {
                        if (!Water->disableWaterSplash) {
                            if (waterSection) {
                                EntityWater *splash = CREATE_ENTITY(Water, INT_TO_VOID(WATER_SPLASH), player->position.x,
                                                                    waterSection->position.y - (waterSection->size.y >> 1));
                                splash->childPtr    = waterSection;
                                splash->drawGroup   = player->drawGroup;
                            }
                            else {
                                CREATE_ENTITY(Water, INT_TO_VOID(WATER_SPLASH), player->position.x, Water->waterLevel);
                            }

                            RSDK.PlaySfx(Water->sfxSplash, false, 0xFF);
                        }

                        if (player->velocity.y >= -TO_FIXED(4)) {
                            player->velocity.y <<= 1;
                            if (player->velocity.y < -TO_FIXED(16))
                                player->velocity.y = -TO_FIXED(16);
                        }
                    }
                }
                else {
                    // if we're not underwater already but we would otherwise be
                    if (abs(player->groundVel) >= 0x78000) {
                        Hitbox *playerHitbox = Player_GetHitbox(player);
                        if (abs(player->position.y + (playerHitbox->bottom << 16) - Water->waterLevel) <= 0x40000 && player->groundedStore) {
                            Water->wakePosX[playerID] = player->position.x;
                            Water->wakeDir[playerID]  = player->groundVel < 0;
                            if (!player->onGround) {
                                player->onGround   = true;
                                player->position.y = Water->waterLevel - (playerHitbox->bottom << 16);
                            }
                        }
                    }
                }

                if (!player->sidekick && player->drownTimer >= 1080) {
                    player->drownTimer = 0;
                    Music_JingleFadeOut(TRACK_DROWNING, false);
                }
            }
            else {
                bool32 notUnderwater = player->underwater == 0;
                player->underwater   = waterID;

                if (notUnderwater) {
                    Player_UpdatePhysicsState(player);
                    if (player->velocity.y && (!Current || !((1 << RSDK.GetEntitySlot(player)) & Current->activePlayers))) {
                        if (!Water->disableWaterSplash) {
                            if (currentPool) {
                                EntityWater *splash = CREATE_ENTITY(Water, INT_TO_VOID(WATER_SPLASH), player->position.x,
                                                                    currentPool->position.y - (currentPool->size.x >> 1));
                                splash->drawGroup   = player->drawGroup;
                                splash->childPtr    = currentPool;
                            }
                            else {
                                CREATE_ENTITY(Water, INT_TO_VOID(WATER_SPLASH), player->position.x, Water->waterLevel);
                            }

                            RSDK.PlaySfx(Water->sfxSplash, false, 255);
                        }

                        player->velocity.y >>= 2;
                    }

                    player->velocity.x >>= 1;
                    if (player->collisionMode == CMODE_FLOOR)
                        player->groundVel >>= 1;

                    player->drownTimer                = 0;
                    Water->constBubbleTimer[playerID] = 52;
                    Water->unused1[playerID]          = 0;
                }
                else {
                    if (player->invincibleTimer <= 0) {
                        if (player->shield == SHIELD_FIRE) {
                            // No cool smoke fx in mania, just a loss of shield :(
                            player->shield = SHIELD_NONE;
                            destroyEntity(RSDK_GET_ENTITY(Player->playerCount + RSDK.GetEntitySlot(player), Shield));
                        }

                        if (player->shield == SHIELD_LIGHTNING) {
                            // No cool electric flash fx in mania, just a loss of shield :(
                            player->shield = SHIELD_NONE;
                            destroyEntity(RSDK_GET_ENTITY(Player->playerCount + RSDK.GetEntitySlot(player), Shield));
                        }
                    }

                    if (player->shield != SHIELD_BUBBLE) {
                        Water_SpawnBubble(player, playerID);

                        bool32 playAlertSfx = false;
                        switch (++player->drownTimer) {
                            default: break;

                            case 360:
                            case 660:
                            case 960:
                                if (!player->sidekick)
                                    RSDK.PlaySfx(Water->sfxWarning, false, 0xFF);
                                break;

                            case 1080:
#if MANIA_USE_PLUS
                                if (globals->gameMode != MODE_COMPETITION && globals->gameMode != MODE_ENCORE) {
#else
                                if (globals->gameMode != MODE_COMPETITION) {
#endif
                                    if (!player->sidekick)
                                        Music_PlayJingle(TRACK_DROWNING);
                                }

                                Water_SpawnCountDownBubble(player, playerID, 5);
                                playAlertSfx = true;
                                break;

                            case 1140: playAlertSfx = true; break;

                            case 1200:
                                Water_SpawnCountDownBubble(player, playerID, 4);
                                playAlertSfx = true;
                                break;

                            case 1260: playAlertSfx = true; break;

                            case 1320:
                                Water_SpawnCountDownBubble(player, playerID, 3);
                                playAlertSfx = true;
                                break;

                            case 1380: playAlertSfx = true; break;

                            case 1440:
                                Water_SpawnCountDownBubble(player, playerID, 2);
                                playAlertSfx = true;
                                break;

                            case 1500: playAlertSfx = true; break;

                            case 1560:
                                Water_SpawnCountDownBubble(player, playerID, 1);
                                playAlertSfx = true;
                                break;

                            case 1620: playAlertSfx = true; break;

                            case 1680:
                                Water_SpawnCountDownBubble(player, playerID, 0);
                                playAlertSfx = true;
                                break;

                            case 1740: playAlertSfx = true; break;

                            case 1800:
                                player->deathType = PLAYER_DEATH_DROWN;
                                if (!pool)
                                    player->drawGroup = Zone->playerDrawGroup[1];
                                playAlertSfx = true;
                                break;
                        }

                        if (playAlertSfx) {
                            if (
#if MANIA_USE_PLUS
                                globals->gameMode == MODE_ENCORE ||
#endif
                                globals->gameMode == MODE_COMPETITION)
                                RSDK.PlaySfx(Water->sfxDrownAlert, false, 255);
                        }
                    }
                }
            }
        }

        if (self->state == Player_State_FlyToPlayer && player->abilityPtrs[0]) {
            self->position.x = player->position.x;
            self->position.y = player->position.y;
        }
    }
}

void Water_State_Pool(void)
{
    // nothing, its handled by the water level type
}

void Water_State_Splash(void)
{
    RSDK_THIS(Water);

    EntityWater *water = self->childPtr;
    if (water) {
        if (water != (EntityWater *)1)
            self->position.y = water->position.y - (water->size.y >> 1);
    }
    else {
        self->position.y = Water->waterLevel;
    }

    RSDK.ProcessAnimation(&self->animator);

    if (self->animator.frameID == self->animator.frameCount - 1)
        destroyEntity(self);
}

void Water_HandleBubbleMovement(void)
{
    RSDK_THIS(Water);

    if (self->bubbleVelocity.x || self->bubbleVelocity.y) {
        self->position.x += self->bubbleVelocity.x;
        self->position.y += self->bubbleVelocity.y;
    }
    else {
        self->position.x += self->velocity.x;
        self->position.y += self->velocity.y;
    }

    self->position.x += self->bubbleOffset.x;
    self->position.y += self->bubbleOffset.y;

    int32 anim = self->animator.animationID;
    if ((anim == 3 && self->animator.frameID < 12) || anim == 4 || anim == 5 || (anim == 7 && !self->activePlayers)) {
        self->position.x = (RSDK.Sin512(self->angle) << 9) + self->bubbleX;
        self->angle      = (self->angle + 4) & 0x1FF;
    }

    if (self->position.y < Water->waterLevel) {
        bool32 inWater = false;
        foreach_active(Water, pool)
        {
            if (pool->type == WATER_POOL && RSDK.CheckObjectCollisionTouchBox(pool, &pool->hitbox, self, &Water->hitboxPoint))
                inWater = true;
        }

        if (!inWater) {
            if (self->animator.animationID == 3 && self->animator.frameID > 12) {
                RSDK.SetSpriteAnimation(Water->aniFrames, 6, &self->animator, false, 0);
                self->velocity.y = 0;
            }
            else if (self->animator.animationID == 7) {
                Water_PopBigBubble(self, false);
            }
            else {
                destroyEntity(self);
            }
        }
    }
}

void Water_PopBigBubble(EntityWater *self, bool32 jumpedOut)
{
    if (self->timer <= 0) {
        RSDK.SetSpriteAnimation(Water->aniFrames, 6, &self->animator, true, 0);
        self->velocity.x = 0;
        self->velocity.y = 0;

        RSDK.PlaySfx(Water->sfxDNABurst, false, 0xFF);

        foreach_active(Player, player)
        {
            int32 playerID = RSDK.GetEntitySlot(player);
            if ((1 << playerID) & self->activePlayers) {
                if (jumpedOut) {
                    RSDK.SetSpriteAnimation(player->aniFrames, ANI_JUMP, &player->animator, true, 0);
                }
                else {
                    if (player->state != Player_State_Static || player->animator.animationID != ANI_BUBBLE) {
                        EntityShield *shield = RSDK_GET_ENTITY(Player->playerCount + playerID, Shield);
                        if (shield)
                            shield->visible = true;
                        self->activePlayers &= ~(1 << playerID);
                    }
                    else {
                        RSDK.SetSpriteAnimation(player->aniFrames, ANI_AIR_WALK, &player->animator, true, 0);
                        EntityShield *shield = RSDK_GET_ENTITY(Player->playerCount + playerID, Shield);
                        if (shield)
                            shield->visible = true;
                        self->activePlayers &= ~(1 << playerID);
                    }
                }

                player->state = Player_State_Air;
            }
        }
    }
}

void Water_State_Bubble(void)
{
    RSDK_THIS(Water);

    EntityPlayer *playerPtr = (EntityPlayer *)self->childPtr;

    if (self->animator.animationID == 6 && self->animator.frameID == self->animator.frameCount - 1)
        destroyEntity(self);

    if (playerPtr && playerPtr->state == Player_State_Bubble && self->animator.frameID < 3)
        self->bubbleX += 0x40000;

    if (self->speed != -1) {
        if (self->speed) {
            self->bubbleX += self->velocity.x;
            self->velocity.x += self->speed;
        }

        Water_HandleBubbleMovement();

        if (self->tileCollisions != TILECOLLISION_NONE) {
            if (RSDK.ObjectTileCollision(self, Zone->collisionLayers, CMODE_FLOOR, 0, 0, TO_FIXED(16), false)) {
                while (RSDK.ObjectTileCollision(self, Zone->collisionLayers, CMODE_FLOOR, 0, 0, TO_FIXED(16), 0)) self->position.y -= TO_FIXED(1);
            }
            else {
                while (RSDK.ObjectTileCollision(self, Zone->collisionLayers, CMODE_ROOF, 0, 0, -TO_FIXED(16), false)
                       && RSDK.ObjectTileCollision(self, Zone->collisionLayers, CMODE_ROOF, 0, 0, -TO_FIXED(16), false)) {
                    self->position.y += TO_FIXED(1);
                }
            }
        }
    }

    RSDK.ProcessAnimation(&self->animator);

    if (self->animator.frameID >= 13 || self->animator.animationID == 7) {
        if (self->isBigBubble) {
            if (self->bigBubbleTimer == 16) {
                RSDK.SetSpriteAnimation(Water->bigBubbleFrames, 7, &self->animator, true, 0);
                self->scale.x = 0x180;
                self->scale.y = 0x180;
            }

            if (self->bigBubbleTimer <= 0) {
                self->activePlayers   = 0;
                self->releasedPlayers = 0;
                self->state           = Water_State_BigBubble;
            }
            else {
                self->bigBubbleTimer--;
            }
        }
        else {
            foreach_active(Player, player)
            {
                if (Player_CheckValidState(player) || player->state == Player_State_FlyToPlayer) {
                    if (player->shield != SHIELD_BUBBLE && player->underwater && !Water_GetPlayerBubble(player)
                        && player->position.x >= self->position.x - TO_FIXED(16) && player->position.x <= self->position.x + TO_FIXED(16)) {

                        bool32 inWater = false;
                        if (player->animator.animationID == ANI_FAN) {
                            if (player->position.y >= self->position.y - TO_FIXED(16))
                                inWater = (player->position.y <= self->position.y + TO_FIXED(16));
                        }
                        else {
                            if (player->position.y > self->position.y)
                                inWater = (player->position.y <= self->position.y + TO_FIXED(16));
                        }

                        if (inWater) {
                            bool32 inBubble = false;
                            if (!(self->bubbleFlags & 1) && player->sidekick) {
                                self->bubbleFlags |= 1;
                                inBubble = true;
                            }

                            if (!player->sidekick || inBubble) {
                                if (!inBubble) {
                                    self->state       = Water_State_BubbleBreathed;
                                    self->countdownID = 0;
                                    self->velocity.y  = 0;
                                    self->childPtr    = player;
                                }

                                if (player->state != Current_PlayerState_Right && player->state != Current_PlayerState_Left
                                    && player->state != Current_PlayerState_Up && player->state != Current_PlayerState_Down) {
                                    player->velocity.x = 0;
                                    player->velocity.y = 0;
                                    player->groundVel  = 0;
                                    bool32 canBreathe  = true;

                                    int32 anim = player->animator.animationID;
                                    if (player->characterID == ID_TAILS) {
                                        canBreathe = anim != ANI_FLY && anim != ANI_FLY_TIRED && anim != ANI_FLY_LIFT && anim != ANI_SWIM
                                                     && anim != ANI_SWIM_LIFT;
                                    }
                                    else if (player->characterID == ID_KNUCKLES) {
                                        canBreathe = anim != ANI_LEDGE_PULL_UP && anim != ANI_GLIDE && anim != ANI_GLIDE_SLIDE
                                                     && anim != ANI_CLIMB_IDLE && anim != ANI_CLIMB_UP && anim != ANI_CLIMB_DOWN;
                                    }

                                    if (canBreathe && (anim != ANI_FAN && anim != ANI_CLING)) {
                                        RSDK.SetSpriteAnimation(player->aniFrames, ANI_BREATHE, &player->animator, false, 0);

                                        if (!player->sidekick)
                                            self->playerInBubble = true;
                                    }

                                    if (player->state == Player_State_FlyCarried) {
                                        player->state                                        = Player_State_Air;
                                        RSDK_GET_ENTITY(SLOT_PLAYER2, Player)->flyCarryTimer = 30;
                                    }
#if MANIA_USE_PLUS
                                    else if (player->state == Player_State_MightyHammerDrop) {
                                        player->state = Player_State_Air;
                                    }
#endif
                                }

                                player->drownTimer = 0;
                                if (!player->sidekick)
                                    Music_JingleFadeOut(TRACK_DROWNING, false);

                                RSDK.PlaySfx(Water->sfxBreathe, false, 255);
                            }
                        }
                    }
                }
            }
        }
    }

    if (self->speed != -1) {
        if (!RSDK.CheckOnScreen(self, &self->updateRange))
            destroyEntity(self);
    }
}

void Water_State_BubbleBreathed(void)
{
    RSDK_THIS(Water);

    EntityPlayer *player = (EntityPlayer *)self->childPtr;
    if (player->state == Player_State_Hurt || !Player_CheckValidState(player))
        self->playerInBubble = false;

    if (self->speed) {
        self->position.x += self->velocity.x;
        self->velocity.x += self->speed;
    }

    RSDK.ProcessAnimation(&self->animator);

    self->scale.x -= 0x18;
    self->scale.y -= 0x18;
    if (self->scale.x > 0) {
        if (self->playerInBubble)
            RSDK.SetSpriteAnimation(player->aniFrames, ANI_BREATHE, &player->animator, false, 0);
    }
    else {
        self->scale.x = 0;
        self->scale.y = 0;

        if (self->playerInBubble)
            RSDK.SetSpriteAnimation(player->aniFrames, ANI_WALK, &player->animator, false, 0);

        destroyEntity(self);
    }
}

EntityWater *Water_GetPlayerBubble(EntityPlayer *player)
{
    int32 playerID = RSDK.GetEntitySlot(player);

    foreach_active(Water, water)
    {
        if (water->state == Water_State_BigBubble && ((1 << playerID) & water->activePlayers)) {
            foreach_return water;
        }
    }
    return NULL;
}

void Water_State_BigBubble(void)
{
    RSDK_THIS(Water);

    if (self->animator.animationID == 6 && self->animator.frameID == self->animator.frameCount - 1)
        destroyEntity(self);

    Water_HandleBubbleMovement();
    self->countdownID = self->animator.frameID;

    RSDK.ProcessAnimation(&self->animator);

    if (self->animator.frameID == self->countdownID || self->animator.animationID == 7) {
        if (self->scale.x < 0x200) {
            self->scale.y += 8;
            self->scale.x += 8;
        }
    }
    else {
        self->scale.x = 0x180;
        self->scale.y = 0x180;
    }

    if (self->animator.animationID != 6) {
        foreach_active(Player, player)
        {
            int32 playerID = RSDK.GetEntitySlot(player);
            if (!Player_CheckValidState(player) || !player->underwater) {
                continue;
            }

            if (!(self->activePlayers & (1 << playerID)) && !((1 << playerID) & self->releasedPlayers)) {
                if (globals->gameMode == MODE_COMPETITION && self->activePlayers)
                    continue;

                if (Player_CheckCollisionTouch(player, self, &Water->hitboxPlayerBubble) && !Water_GetPlayerBubble(player)) {
                    RSDK.SetSpriteAnimation(player->aniFrames, ANI_BUBBLE, &player->animator, true, 0);
                    player->state        = Player_State_Static;
                    EntityShield *shield = RSDK_GET_ENTITY(Player->playerCount + RSDK.GetEntitySlot(player), Shield);
                    if (shield)
                        shield->visible = false;

                    player->drownTimer = 0;
                    if (!player->sidekick)
                        Music_JingleFadeOut(TRACK_DROWNING, false);

                    RSDK.PlaySfx(Water->sfxDNAGrab, false, 255);
                    self->activePlayers |= 1 << playerID;
                    self->releasedPlayers |= 1 << playerID;
                    if (RSDK.GetEntitySlot(self) >= RESERVE_ENTITY_COUNT) {
                        int32 id = SLOT_BIGBUBBLE_P1;
                        for (; id < SLOT_BIGBUBBLE_P1 + PLAYER_COUNT; ++id) {
                            if (RSDK_GET_ENTITY_GEN(id)->classID == TYPE_BLANK)
                                break;
                        }

                        if (id >= 0 && id < SLOT_BIGBUBBLE_P1 + PLAYER_COUNT) {
                            RSDK.AddDrawListRef(self->drawGroup, id);
                            RSDK.CopyEntity(RSDK_GET_ENTITY(id, Water), self, true);
                            foreach_return;
                        }
                    }
                }
            }

            if ((1 << playerID) & self->activePlayers) {
                if (self->timer > 0) {
                    RSDK.SetSpriteAnimation(player->aniFrames, ANI_BUBBLE, &player->animator, false, 0);
                    player->state = Player_State_Static;
                }

                player->drownTimer = 0;
                player->position.x = self->position.x;
                player->position.y = self->position.y;
                player->velocity.x = self->velocity.x;
                player->velocity.y = self->velocity.y;
                if (player->sidekick) {
                    if (player->left)
                        player->direction = FLIP_X;
                    else if (player->right)
                        player->direction = FLIP_NONE;

                    if (player->jumpPress) {
                        RSDK.SetSpriteAnimation(player->aniFrames, ANI_JUMP, &player->animator, true, 0);
                        player->state = Player_State_Air;
                        self->activePlayers &= ~(1 << playerID);
                        self->releasedPlayers |= 1 << playerID;
                    }
                }
                else {
                    self->drawGroup      = player->drawGroup;
                    self->collisionPlane = player->collisionPlane;
                    if (player->state != Player_State_Static && player->animator.animationID != ANI_BUBBLE) {
                        Water_PopBigBubble(self, false);
                        foreach_return;
                    }

                    int32 xVel = 0;
                    if (player->left) {
                        player->direction = FLIP_X;
                        xVel              = -0x11000;
                    }
                    else if (player->right) {
                        player->direction = FLIP_NONE;
                        xVel              = 0x11000;
                    }

                    int32 yVel = -0x8800;
                    if (player->down)
                        yVel = -0x4400;
                    else if (player->up)
                        yVel = -0x11000;

                    if (xVel - self->velocity.x)
                        self->velocity.x += (2 * ((xVel - self->velocity.x) > 0) - 1) << 11;

                    if (yVel - self->velocity.y)
                        self->velocity.y += (2 * ((yVel - self->velocity.y) > 0) - 1) << 11;

                    if (player->jumpPress) {
                        Water_PopBigBubble(self, true);
                        foreach_return;
                    }
                }
            }

            if ((1 << playerID) & self->releasedPlayers) {
                if (!Player_CheckCollisionTouch(player, self, &Water->hitboxPlayerBubble))
                    self->releasedPlayers &= ~(1 << playerID);
            }
        }

        if (self->timer > 0)
            self->timer--;

        Hitbox hitboxSpike;
        hitboxSpike.left   = -20;
        hitboxSpike.top    = -20;
        hitboxSpike.right  = 20;
        hitboxSpike.bottom = 20;

        foreach_active(Spikes, spikes)
        {
            if (RSDK.CheckObjectCollisionTouchBox(self, &hitboxSpike, spikes, &spikes->hitbox)) {
                Water_PopBigBubble(self, false);
                foreach_return;
            }
        }

        if (RSDK.ObjectTileCollision(self, Zone->collisionLayers, CMODE_ROOF, 0, 0, -TO_FIXED(24), true)
            || RSDK.ObjectTileCollision(self, Zone->collisionLayers, CMODE_RWALL, 0, -TO_FIXED(24), 0, true)
            || RSDK.ObjectTileCollision(self, Zone->collisionLayers, CMODE_LWALL, 0, TO_FIXED(24), 0, true)) {
            Water_PopBigBubble(self, false);
        }
    }
}

void Water_State_BtnBigBubble(void)
{
    RSDK_THIS(Water);

    if (self->taggedButton) {
        if (self->timer <= 0) {
            Hitbox hitbox;
            hitbox.left   = -32;
            hitbox.top    = -32;
            hitbox.right  = 32;
            hitbox.bottom = 32;

            if (self->taggedButton->currentlyActive) {
                foreach_active(Player, player)
                {
                    if (!player->sidekick && Player_CheckCollisionTouch(player, self, &hitbox)) {
                        if (player->animator.animationID != ANI_BUBBLE) {
                            EntityWater *bigBubble = CREATE_ENTITY(Water, INT_TO_VOID(WATER_BUBBLE), self->position.x, self->position.y);
                            RSDK.SetSpriteAnimation(Water->bigBubbleFrames, 7, &bigBubble->animator, true, 0);

                            bigBubble->state          = Water_State_BigBubble;
                            bigBubble->isBigBubble    = true;
                            bigBubble->bigBubbleTimer = 0;
                            bigBubble->velocity.y     = -0x8800;
                            bigBubble->childPtr       = 0;
                            bigBubble->bubbleX        = bigBubble->position.x;
                            bigBubble->timer          = 0x1E;
                            bigBubble->scale.x        = 0x180;
                            bigBubble->scale.y        = 0x180;
                            self->timer               = 60;
                        }
                    }
                }
            }
        }
        else {
            self->timer--;
        }
    }
}

void Water_State_Bubbler(void)
{
    RSDK_THIS(Water);

    self->visible = false;
    if (self->position.y > Water->waterLevel)
        self->visible = true;

    foreach_active(Water, pool)
    {
        if (pool->type == WATER_POOL && RSDK.CheckObjectCollisionTouchBox(pool, &pool->hitbox, self, &Water->hitboxPoint))
            self->visible = true;
    }

    if (self->visible && RSDK.CheckOnScreen(self, &self->updateRange)) {
        if (--self->countdownID < 0) {
            if (!self->bubbleFlags) {
                self->bubbleFlags = 1;
                int8 rand        = RSDK.Rand(0, 0x10000);
                self->bubbleType1 = rand % 6;
                self->bubbleType2 = rand & 12;

                if (!self->dudsRemaining--) {
                    self->bubbleFlags |= 2;
                    self->dudsRemaining = self->numDuds;
                }
            }

            self->countdownID = RSDK.Rand(0, 32);

            EntityWater *bubble         = CREATE_ENTITY(Water, INT_TO_VOID(WATER_BUBBLE), self->position.x, self->position.y - 0x20000);
            int32 bubbleSize            = Water->bubbleSizes[self->bubbleType1 + self->bubbleType2];
            bubble->animator.loopIndex  = bubbleSize;
            bubble->animator.frameCount = bubbleSize + 1;
            if (self->type == WATER_BIG_BUBBLER) {
                bubble->isBigBubble    = true;
                bubble->bigBubbleTimer = 16;
            }
            bubble->position.x += RSDK.Rand(-8, 9) << 16;
            bubble->velocity.y = -0x8800;
            bubble->angle      = 2 * RSDK.Rand(0, 256);

            bubble->childPtr = NULL;
            bubble->bubbleX  = bubble->position.x;
            if (self->bubbleFlags & 2 && (!RSDK.Rand(0, 4) || !self->bubbleType1) && !(self->bubbleFlags & 4)) {
                RSDK.SetSpriteAnimation(Water->aniFrames, 3, &bubble->animator, false, 0);
                bubble->isPermanent = true;
                self->bubbleFlags |= 4;
            }

            if (--self->bubbleType1 < 0) {
                self->bubbleFlags = 0;
                self->countdownID += RSDK.Rand(0, 128) + 128;
            }
        }
    }

    RSDK.ProcessAnimation(&self->animator);
}

void Water_State_Countdown(void)
{
    RSDK_THIS(Water);

    EntityPlayer *player = (EntityPlayer *)self->childPtr;

    if (player->animator.animationID == ANI_FAN) {
        self->bubbleX += player->velocity.x;
        self->position.y += player->velocity.y;
    }

    RSDK.ProcessAnimation(&self->animator);

    bool32 isActive = false;
    if (self->position.y >= Water->waterLevel) {
        isActive = true;
    }
    else {
        foreach_active(Water, pool)
        {
            if (pool->type == WATER_POOL && RSDK.CheckObjectCollisionTouchBox(pool, &pool->hitbox, self, &Water->hitboxPoint)) {
                isActive = true;
            }
        }
    }

    if ((self->animator.animationID != 7 || self->animator.frameID != self->animator.frameCount - 1) && isActive) {
        self->position.y += self->velocity.y;
        self->position.x = (RSDK.Sin512(self->angle) << 9) + self->bubbleX;
        self->angle      = (self->angle + 4) & 0x1FF;
    }
    else {
        RSDK.SetSpriteAnimation(Water->aniFrames, self->countdownID + 8, &self->animator, true, 0);

        if (player->camera) {
            self->size.x = (self->position.x & 0xFFFF0000) - (player->camera->position.x & 0xFFFF0000);
            self->size.y = (self->position.y & 0xFFFF0000) - (player->camera->position.y & 0xFFFF0000);
        }
        else {
            self->size.x = (self->position.x & 0xFFFF0000) - (player->position.x & 0xFFFF0000);
            self->size.y = (self->position.y & 0xFFFF0000) - (player->position.y & 0xFFFF0000);
        }

        self->state = Water_State_CountdownFollow;
    }
}

void Water_State_CountdownFollow(void)
{
    RSDK_THIS(Water);

    RSDK.ProcessAnimation(&self->animator);

    if (self->angle >= 0x280) {
        self->scale.x -= 8;
        self->scale.y -= 8;
        if (self->scale.x <= 0)
            destroyEntity(self);
    }
    else {
        self->scale.x = (RSDK.Sin256(self->angle) >> 1) + 0x200;
        self->scale.y = (RSDK.Sin256(self->angle + 0x80) >> 1) + 0x200;

        self->angle += 6;
    }
}

void Water_State_HeightTrigger(void)
{
    RSDK_THIS(Water);

    bool32 activated = false;
    if (self->taggedButton) {
        EntityButton *button = self->taggedButton;
        if (button->currentlyActive) {
            Water->moveWaterLevel = true;
            activated             = true;
        }
    }

    int32 px = self->position.x + 1;
    if (!activated) {
        foreach_active(Player, player)
        {
            if (!RSDK.GetEntitySlot(player)) {
                if (abs(self->position.x - player->position.x) < self->updateRange.x) {
                    if (abs(self->position.y - player->position.y) < self->updateRange.y) {
                        activated = true;
                        px        = player->position.x;
                    }
                }
            }
        }
    }

    if (activated) {
        if (self->taggedButton)
            Water->targetWaterLevel = self->position.y;
        else if (px <= self->position.x)
            Water->targetWaterLevel = self->height.x;
        else
            Water->targetWaterLevel = self->height.y;

        Water->waterMoveSpeed = self->speed << 15;
        if (self->destroyOnTrigger)
            destroyEntity(self);
    }
}

void Water_Draw_Water(void)
{
    RSDK_THIS(Water);
    RSDKScreenInfo *screen = &ScreenInfo[SceneInfo->currentScreenID];

    Vector2 drawPos;
    drawPos.x = ((screen->position.x & 0xFFFFFFC0) + 32) << 16;
    drawPos.y = Water->waterLevel;
    for (int32 i = (screen->size.x >> 6) + 2; i > 0; --i) {
        RSDK.DrawSprite(&self->animator, &drawPos, false);
        drawPos.x += TO_FIXED(64);
    }

    self->drawFX |= FX_FLIP;
    for (int32 i = 0; i < PLAYER_COUNT; ++i) {
        if (Water->wakePosX[i] > 0) {
            self->direction = Water->wakeDir[i];
            drawPos.x       = Water->wakePosX[i];
            RSDK.DrawSprite(&Water->wakeAnimator, &drawPos, false);
        }
    }

    self->drawFX &= ~FX_FLIP;
}

void Water_Draw_Pool(void)
{
    RSDK_THIS(Water);

    RSDK.DrawRect(self->position.x - (self->size.x >> 1), self->position.y - (self->size.y >> 1), self->size.x, self->size.y,
                  (self->r << 16) | (self->g << 8) | self->b, 0x100, INK_SUB, false);
}

void Water_Draw_Splash(void)
{
    RSDK_THIS(Water);

    RSDK.DrawSprite(&self->animator, NULL, false);
}

void Water_Draw_Countdown(void)
{
    Vector2 drawPos;

    RSDK_THIS(Water);
    if (self->state == Water_State_Countdown) {
        drawPos.x = self->position.x;
        drawPos.y = self->position.y;
    }
    else {
        EntityPlayer *player = (EntityPlayer *)self->childPtr;
        if (player->camera) {
            drawPos.x = player->camera->position.x + self->size.x;
            drawPos.y = player->camera->position.y + self->size.y;
        }
        else {
            drawPos.x = player->position.x + self->size.x;
            drawPos.y = player->position.y + self->size.y;
        }
    }

    RSDK.DrawSprite(&self->animator, &drawPos, false);
}

void Water_Draw_Bubbler(void)
{
    RSDK_THIS(Water);

    RSDK.DrawSprite(&self->animator, NULL, false);
}

void Water_Draw_Bubble(void)
{
    RSDK_THIS(Water);

    RSDK.DrawSprite(&self->animator, NULL, false);
}

#if GAME_INCLUDE_EDITOR
void Water_EditorDraw(void)
{
    RSDK_THIS(Water);

    self->updateRange.x = TO_FIXED(128);
    self->updateRange.y = TO_FIXED(128);

    self->inkEffect = INK_NONE;
    switch (self->type) {
        case WATER_WATERLEVEL:
            self->inkEffect = INK_ADD;
            self->alpha     = RSDK.CheckSceneFolder("AIZ") ? 0x60 : 0xE0;
            RSDK.SetSpriteAnimation(Water->aniFrames, 0, &self->animator, true, 0);

            Water->waterLevel = self->position.y;

            Vector2 drawPos;
            drawPos.x = (((self->position.x >> 16) & 0xFFFFFFC0) + 32) << 16;
            drawPos.y = self->position.y;
            for (int32 i = (WIDE_SCR_XSIZE >> 6) + 2; i > 0; --i) {
                RSDK.DrawSprite(&self->animator, &drawPos, false);
                drawPos.x += TO_FIXED(64);
            }
            break;

        case WATER_POOL:
            self->drawFX        = FX_FLIP;
            self->updateRange.x = self->size.x >> 1;
            self->updateRange.y = self->size.y >> 1;

            self->inkEffect = INK_BLEND;
            RSDK.DrawRect(self->position.x - (self->size.x >> 1), self->position.y - (self->size.y >> 1), self->size.x, self->size.y,
                          (self->r << 16) | (self->g << 8) | self->b, 0x20, INK_ALPHA, false);
            if (showGizmos()) {
                self->inkEffect = INK_NONE;
                DrawHelpers_DrawRectOutline(self->position.x, self->position.y, self->size.x, self->size.y, 0xFFFF00);
            }
            break;

        case WATER_BUBBLER:
        case WATER_BIG_BUBBLER:
            self->inkEffect = INK_ADD;
            self->alpha     = 0x100;
            RSDK.SetSpriteAnimation(Water->aniFrames, 2, &self->animator, true, 0);

            Water_Draw_Bubbler();
            break;

        case WATER_HEIGHT_TRIGGER:
            self->active  = ACTIVE_BOUNDS;
            self->visible = false;

            RSDK.SetSpriteAnimation(Water->aniFrames, 0, &self->animator, true, 0);
            RSDK.DrawSprite(&self->animator, NULL, false);

            if (showGizmos()) {
                Water_SetupTagLink();

                RSDK_DRAWING_OVERLAY(true);
                if (self->taggedButton) {
                    DrawHelpers_DrawArrow(self->taggedButton->position.x, self->taggedButton->position.y, self->position.x, self->position.y,
                                          0xFFFF00, INK_NONE, 0xFF);
                }
                RSDK_DRAWING_OVERLAY(false);
            }
            break;

        case WATER_BTN_BIG_BUBBLE:
            self->drawFX    = FX_SCALE;
            self->inkEffect = INK_ADD;
            self->alpha     = 0x100;
            self->scale.x   = 0x200;
            self->scale.y   = 0x200;
            RSDK.SetSpriteAnimation(Water->bigBubbleFrames, 7, &self->animator, true, 0);

            Water_Draw_Bubble();

            if (showGizmos()) {
                Water_SetupTagLink();

                RSDK_DRAWING_OVERLAY(true);
                if (self->taggedButton) {
                    DrawHelpers_DrawArrow(self->taggedButton->position.x, self->taggedButton->position.y, self->position.x, self->position.y,
                                          0xFFFF00, INK_NONE, 0xFF);
                }
                RSDK_DRAWING_OVERLAY(false);
            }
            break;

        default: break;
    }
}

void Water_EditorLoad(void)
{
    Water->aniFrames = RSDK.LoadSpriteAnimation("Global/Water.bin", SCOPE_STAGE);
    if (RSDK.CheckSceneFolder("HCZ")) {
        Water->wakeFrames      = RSDK.LoadSpriteAnimation("HCZ/Wake.bin", SCOPE_STAGE);
        Water->bigBubbleFrames = RSDK.LoadSpriteAnimation("HCZ/BigBubble.bin", SCOPE_STAGE);
        RSDK.SetSpriteAnimation(Water->wakeFrames, 0, &Water->wakeAnimator, true, 0);
    }

    RSDK_ACTIVE_VAR(Water, type);
    RSDK_ENUM_VAR("Water Level", WATER_WATERLEVEL);
    RSDK_ENUM_VAR("Pool", WATER_POOL);
    RSDK_ENUM_VAR("Bubbler", WATER_BUBBLER);
    RSDK_ENUM_VAR("Height Trigger", WATER_HEIGHT_TRIGGER);
    RSDK_ENUM_VAR("Big Bubbler", WATER_BIG_BUBBLER);
    RSDK_ENUM_VAR("Btn Big Bubble", WATER_BTN_BIG_BUBBLE);

    RSDK_ACTIVE_VAR(Water, priority);
    RSDK_ENUM_VAR("Lowest", WATER_PRIORITY_LOWEST);
    RSDK_ENUM_VAR("Low", WATER_PRIORITY_LOW);
    RSDK_ENUM_VAR("High", WATER_PRIORITY_HIGH);
    RSDK_ENUM_VAR("Highest", WATER_PRIORITY_HIGHEST);
}
#endif

void Water_Serialize(void)
{
    RSDK_EDITABLE_VAR(Water, VAR_ENUM, type);
    RSDK_EDITABLE_VAR(Water, VAR_UINT8, numDuds);
    RSDK_EDITABLE_VAR(Water, VAR_VECTOR2, size);
    RSDK_EDITABLE_VAR(Water, VAR_VECTOR2, height);
    RSDK_EDITABLE_VAR(Water, VAR_ENUM, speed);
    RSDK_EDITABLE_VAR(Water, VAR_ENUM, buttonTag);
    RSDK_EDITABLE_VAR(Water, VAR_UINT8, r);
    RSDK_EDITABLE_VAR(Water, VAR_UINT8, g);
    RSDK_EDITABLE_VAR(Water, VAR_UINT8, b);
    RSDK_EDITABLE_VAR(Water, VAR_UINT8, priority);
    RSDK_EDITABLE_VAR(Water, VAR_BOOL, destroyOnTrigger);
}