BreakableWall.c

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

#include "Game.h"

ObjectBreakableWall *BreakableWall;

void BreakableWall_Update(void)
{
    RSDK_THIS(BreakableWall);

    StateMachine_Run(self->state);
}

void BreakableWall_LateUpdate(void) {}

void BreakableWall_StaticUpdate(void) {}

void BreakableWall_Draw(void)
{
    RSDK_THIS(BreakableWall);

    StateMachine_Run(self->stateDraw);
}

void BreakableWall_Create(void *data)
{
    RSDK_THIS(BreakableWall);

    self->gravityStrength = 0x3800;

    if (data) {
        int32 type          = VOID_TO_INT(data);
        self->visible       = true;
        self->updateRange.x = TO_FIXED(16);
        self->updateRange.y = TO_FIXED(16);
        self->active        = ACTIVE_NORMAL;
        self->drawFX        = FX_FLIP | (self->velocity.x != 0 ? FX_ROTATE : FX_NONE);
        self->tileRotation  = RSDK.Rand(-8, 8);

        switch (type) {
            case BREAKWALL_TILE_FIXED:
                self->state     = BreakableWall_State_Tile;
                self->stateDraw = BreakableWall_Draw_Tile;
                break;

            default:
            case BREAKWALL_TILE_DYNAMIC:
                self->state     = BreakableWall_State_FallingTile;
                self->stateDraw = StateMachine_None;
                break;
        }
    }
    else {
        self->drawFX |= FX_FLIP;

        if (!SceneInfo->inEditor) {
            self->visible       = false;
            self->drawGroup     = Zone->objectDrawGroup[1];
            self->active        = ACTIVE_BOUNDS;
            self->updateRange.x = TO_FIXED(128);
            self->updateRange.y = TO_FIXED(128);
            self->priority      = self->priority == BREAKWALL_PRIO_HIGH ? Zone->fgLayer[1] : Zone->fgLayer[0];

            self->size.x >>= 0x10;
            self->size.y >>= 0x10;

            switch (self->type) {
                case BREAKWALL_TYPE_WALL:
                    if (!self->size.x) {
                        self->size.x = 2;
                        self->size.y = 4;
                    }

                    self->state     = BreakableWall_State_Wall;
                    self->stateDraw = BreakableWall_Draw_Wall;
                    break;

                case BREAKWALL_TYPE_FLOOR:
                    if (!self->size.x) {
                        self->size.x = 2;
                        self->size.y = 2;
                    }

                    self->state     = BreakableWall_State_Floor;
                    self->stateDraw = BreakableWall_Draw_Floor;
                    break;

                case BREAKWALL_TYPE_BURROWFLOOR:
                case BREAKWALL_TYPE_BURROWFLOOR_B:
                    if (!self->size.x)
                        self->size.x = 2;

                    self->state     = BreakableWall_State_BurrowFloor;
                    self->stateDraw = BreakableWall_Draw_Floor;
                    break;

                case BREAKWALL_TYPE_BURROWFLOORUP:
                    if (!self->size.x)
                        self->size.x = 2;

                    self->state     = BreakableWall_State_BurrowFloorUp;
                    self->stateDraw = BreakableWall_Draw_Floor;
                    break;

                case BREAKWALL_TYPE_CEILING:
                    if (!self->size.x) {
                        self->size.x = 2;
                        self->size.y = 2;
                    }

                    self->state     = BreakableWall_State_Ceiling;
                    self->stateDraw = BreakableWall_Draw_Floor;
                    break;

                default: break;
            }

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

void BreakableWall_StageLoad(void)
{
    BreakableWall->aniFrames = RSDK.LoadSpriteAnimation("Global/TicMark.bin", SCOPE_STAGE);
    RSDK.SetSpriteAnimation(BreakableWall->aniFrames, 0, &BreakableWall->animator, true, 0);

    if (RSDK.CheckSceneFolder("AIZ"))
        BreakableWall->sfxBreak = RSDK.GetSfx("Stage/LedgeBreak3.wav");
    else
        BreakableWall->sfxBreak = RSDK.GetSfx("Stage/LedgeBreak.wav");

    BreakableWall->farPlaneLayer = RSDK.GetTileLayerID("Far Plane");
}

// States
void BreakableWall_State_BurrowFloorUp(void)
{
    RSDK_THIS(BreakableWall);

    self->visible = DebugMode->debugActive;

    BreakableWall_CheckBreak_BurrowFloorUp();
}
void BreakableWall_State_Ceiling(void)
{
    RSDK_THIS(BreakableWall);

    self->visible = DebugMode->debugActive;

    BreakableWall_CheckBreak_Ceiling();
}
void BreakableWall_State_FallingTile(void)
{
    RSDK_THIS(BreakableWall);

    if (--self->timer <= 0) {
        RSDK.SetTile(self->targetLayer, self->tilePos.x, self->tilePos.y, -1);

        if (self->drawGroup < Zone->objectDrawGroup[0] && BreakableWall->farPlaneLayer != (uint16)-1) {
            RSDK.SetTile(BreakableWall->farPlaneLayer, self->tilePos.x, self->tilePos.y, -1);
        }

        self->state     = BreakableWall_State_Tile;
        self->stateDraw = BreakableWall_Draw_Tile;
    }
}
void BreakableWall_State_Wall(void)
{
    RSDK_THIS(BreakableWall);

    self->visible = DebugMode->debugActive;

    BreakableWall_CheckBreak_Wall();
}
void BreakableWall_State_Tile(void)
{
    RSDK_THIS(BreakableWall);

    self->position.x += self->velocity.x;
    self->position.y += self->velocity.y;
    self->velocity.y += self->gravityStrength;

    if (self->velocity.x)
        self->rotation += self->tileRotation;

    if (self->drawGroup >= Zone->objectDrawGroup[0]) {
        if (!RSDK.CheckOnScreen(self, &self->updateRange))
            destroyEntity(self);
    }
    else {
        if (++self->timer == 120)
            destroyEntity(self);
    }
}
void BreakableWall_State_Floor(void)
{
    RSDK_THIS(BreakableWall);

    self->visible = DebugMode->debugActive;

    BreakableWall_CheckBreak_Floor();
}
void BreakableWall_State_BurrowFloor(void)
{
    RSDK_THIS(BreakableWall);

    self->visible = DebugMode->debugActive;

    BreakableWall_CheckBreak_BurrowFloor();
}

// Draw States
void BreakableWall_Draw_Wall(void)
{
    RSDK_THIS(BreakableWall);

    Vector2 drawPos;
    drawPos.x = self->position.x - (self->size.x << 19);
    drawPos.y = self->position.y - (self->size.y << 19);

    RSDK.DrawLine(drawPos.x - 0x10000, drawPos.y - 0x10000, drawPos.x + (self->size.x << 20), drawPos.y - 0x10000, 0xE0E0E0, 0, INK_NONE, false);
    RSDK.DrawLine(drawPos.x - 0x10000, drawPos.y + (self->size.y << 20), drawPos.x + (self->size.x << 20), drawPos.y + (self->size.y << 20), 0xE0E0E0,
                  0, INK_NONE, false);
    RSDK.DrawLine(drawPos.x - 0x10000, drawPos.y - 0x10000, drawPos.x - 0x10000, drawPos.y + (self->size.y << 20), 0xE0E0E0, 0, INK_NONE, false);
    RSDK.DrawLine(drawPos.x + (self->size.x << 20), drawPos.y - 0x10000, drawPos.x + (self->size.x << 20), drawPos.y + (self->size.y << 20), 0xE0E0E0,
                  0, INK_NONE, false);

    self->direction = FLIP_NONE;
    RSDK.DrawSprite(&BreakableWall->animator, &drawPos, false);

    drawPos.x += self->size.x << 20;
    self->direction = FLIP_X;
    RSDK.DrawSprite(&BreakableWall->animator, &drawPos, false);

    drawPos.y += self->size.y << 20;
    self->direction = FLIP_XY;
    RSDK.DrawSprite(&BreakableWall->animator, &drawPos, false);

    drawPos.x -= self->size.x << 20;
    self->direction = FLIP_Y;
    RSDK.DrawSprite(&BreakableWall->animator, &drawPos, false);
}

// The... same function as above?
void BreakableWall_Draw_Floor(void)
{
    RSDK_THIS(BreakableWall);

    Vector2 drawPos;
    drawPos.x = self->position.x - (self->size.x << 19);
    drawPos.y = self->position.y - (self->size.y << 19);

    RSDK.DrawLine(drawPos.x - TO_FIXED(1), drawPos.y - TO_FIXED(1), drawPos.x + (self->size.x << 20), drawPos.y - TO_FIXED(1), 0xE0E0E0, 0x00,
                  INK_NONE, false);
    RSDK.DrawLine(drawPos.x - TO_FIXED(1), drawPos.y + (self->size.y << 20), drawPos.x + (self->size.x << 20), drawPos.y + (self->size.y << 20),
                  0xE0E0E0, 0x00, INK_NONE, false);
    RSDK.DrawLine(drawPos.x - TO_FIXED(1), drawPos.y - TO_FIXED(1), drawPos.x - TO_FIXED(1), drawPos.y + (self->size.y << 20), 0xE0E0E0, 0x00,
                  INK_NONE, false);
    RSDK.DrawLine(drawPos.x + (self->size.x << 20), drawPos.y - TO_FIXED(1), drawPos.x + (self->size.x << 20), drawPos.y + (self->size.y << 20),
                  0xE0E0E0, 0x00, INK_NONE, false);

    self->direction = FLIP_NONE;
    RSDK.DrawSprite(&BreakableWall->animator, &drawPos, false);

    drawPos.x += self->size.x << 20;
    self->direction = FLIP_X;
    RSDK.DrawSprite(&BreakableWall->animator, &drawPos, false);

    drawPos.y += self->size.y << 20;
    self->direction = FLIP_XY;
    RSDK.DrawSprite(&BreakableWall->animator, &drawPos, false);

    drawPos.x -= self->size.x << 20;
    self->direction = FLIP_Y;
    RSDK.DrawSprite(&BreakableWall->animator, &drawPos, false);
}
void BreakableWall_Draw_Tile(void)
{
    RSDK_THIS(BreakableWall);

    self->angle = self->rotation;
    RSDK.DrawTile(&self->tileInfo, 1, 1, NULL, NULL, false);
}

// Breaking
void BreakableWall_CheckBreak_Wall(void)
{
    RSDK_THIS(BreakableWall);

    foreach_active(Player, player)
    {
#if MANIA_USE_PLUS
        if (self->onlyMighty) {
            if (player->characterID != ID_MIGHTY && (!self->onlyKnux || player->characterID != ID_KNUCKLES)) {
                Player_CheckCollisionBox(player, self, &self->hitbox);
                continue;
            }
        }
        else {
            if (self->onlyKnux && player->characterID != ID_KNUCKLES && (!self->onlyMighty || player->characterID != ID_MIGHTY)) {
                Player_CheckCollisionBox(player, self, &self->hitbox);
                continue;
            }
        }
#else
        if (self->onlyKnux && player->characterID != ID_KNUCKLES) {
            Player_CheckCollisionBox(player, self, &self->hitbox);
            continue;
        }
#endif

        bool32 canBreak = abs(player->groundVel) >= 0x48000 && player->onGround && player->animator.animationID == ANI_JUMP;

        if (player->shield == SHIELD_FIRE) {
            EntityShield *shield = RSDK_GET_ENTITY(Player->playerCount + RSDK.GetEntitySlot(player), Shield);
            canBreak |= shield->shieldAnimator.animationID == SHIELDANI_FIREATTACK;
        }

        switch (player->characterID) {
            default: break;

            case ID_SONIC: canBreak |= player->superState == SUPERSTATE_SUPER; break;

            case ID_KNUCKLES: canBreak = true; break;
        }

        if (player->state == Ice_PlayerState_Frozen)
            canBreak |= abs(player->groundVel) >= 0x48000;

        if (canBreak && !player->sidekick) {
            if (Player_CheckCollisionTouch(player, self, &self->hitbox)) {
                BreakableWall_Break(self, player->position.x > self->position.x);

                if (player->characterID == ID_KNUCKLES) {
                    if (player->animator.animationID == ANI_GLIDE) {
                        player->abilitySpeed -= player->abilitySpeed >> 2;
                        player->velocity.x -= player->velocity.x >> 2;
                        if (abs(player->velocity.x) <= 0x30000) {
                            RSDK.SetSpriteAnimation(player->aniFrames, ANI_GLIDE_DROP, &player->animator, false, 0);
                            player->state = Player_State_KnuxGlideDrop;
                        }
                    }
                    else if (player->animator.animationID == ANI_GLIDE_SLIDE) {
                        player->abilitySpeed -= player->abilitySpeed >> 2;
                        player->velocity.x -= player->velocity.x >> 2;
                    }
                }

                RSDK.PlaySfx(BreakableWall->sfxBreak, false, 255);
                destroyEntity(self);
            }
            continue; // skip to next loop, so we dont do the box collision
        }

        Player_CheckCollisionBox(player, self, &self->hitbox);
    }
}
void BreakableWall_CheckBreak_Floor(void)
{
    RSDK_THIS(BreakableWall);

    foreach_active(Player, player)
    {
#if MANIA_USE_PLUS
        int32 velY = player->velocity.y;
#endif

        if (Player_CheckCollisionBox(player, self, &self->hitbox) == C_TOP) {
#if MANIA_USE_PLUS
            if (self->onlyMighty) {
                if ((player->characterID != ID_MIGHTY || player->animator.animationID != ANI_HAMMERDROP)
                    && (!self->onlyKnux || player->characterID != ID_KNUCKLES)) {
                    Player_CheckCollisionBox(player, self, &self->hitbox);
                    continue;
                }
            }
            else {
                if (self->onlyKnux && player->characterID != ID_KNUCKLES && (!self->onlyMighty || player->characterID != ID_MIGHTY)) {
                    Player_CheckCollisionBox(player, self, &self->hitbox);
                    continue;
                }
            }
#else
            if (self->onlyKnux && player->characterID != ID_KNUCKLES) {
                Player_CheckCollisionBox(player, self, &self->hitbox);
                continue;
            }
#endif

            bool32 canBreak = player->animator.animationID == ANI_JUMP;

            switch (player->characterID) {
                default: break;

                case ID_SONIC:
                    if (!canBreak)
                        canBreak = player->animator.animationID == ANI_DROPDASH;
                    break;

                case ID_KNUCKLES: canBreak = true; break;

#if MANIA_USE_PLUS
                case ID_MIGHTY:
                    if (!canBreak)
                        canBreak = player->state == Player_State_MightyHammerDrop;
                    break;
#endif
            }

            if (player->groundedStore && player->collisionMode != CMODE_LWALL && player->collisionMode != CMODE_RWALL)
                canBreak = false;

            if (canBreak && !player->sidekick) {
                player->onGround = false;

                BreakableWall_Break(self, FLIP_Y);

                RSDK.PlaySfx(BreakableWall->sfxBreak, false, 255);
                BreakableWall_GiveScoreBonus(player);

#if MANIA_USE_PLUS
                if (player->characterID == ID_MIGHTY && player->state == Player_State_MightyHammerDrop)
                    player->velocity.y = velY - TO_FIXED(1);
                else
#endif
                    player->velocity.y = -TO_FIXED(3);

                destroyEntity(self);

                continue; // skip to next loop, so we dont do the box collision
            }
        }

        Player_CheckCollisionBox(player, self, &self->hitbox);
    }
}
void BreakableWall_CheckBreak_BurrowFloor(void)
{
    RSDK_THIS(BreakableWall);

    foreach_active(Player, player)
    {
#if MANIA_USE_PLUS
        int32 velY = player->velocity.y;
#endif
        bool32 onGround = player->onGround;

        if (Player_CheckCollisionBox(player, self, &self->hitbox) == C_TOP && !player->sidekick
            && ((player->collisionPlane == 1 && self->type == BREAKWALL_TYPE_BURROWFLOOR_B) || self->type == BREAKWALL_TYPE_BURROWFLOOR)) {
#if MANIA_USE_PLUS
            if (self->onlyMighty) {
                if ((player->characterID != ID_MIGHTY || player->animator.animationID != ANI_HAMMERDROP)
                    && (!self->onlyKnux || player->characterID != ID_KNUCKLES))
                    continue;
            }
            else {
                if (self->onlyKnux && player->characterID != ID_KNUCKLES && (!self->onlyMighty || player->characterID != ID_MIGHTY))
                    continue;
            }
#else
            if (self->onlyKnux && player->characterID != ID_KNUCKLES)
                continue;
#endif

            bool32 canBreak = player->animator.animationID == ANI_JUMP;

            switch (player->characterID) {
                default: break;

                case ID_SONIC:
                    if (!canBreak)
                        canBreak = player->animator.animationID == ANI_DROPDASH;
                    break;

#if MANIA_USE_PLUS
                case ID_MIGHTY:
                    if (!canBreak)
                        canBreak = player->state == Player_State_MightyHammerDrop;
                    break;
#endif
            }

            if (onGround && player->collisionMode != CMODE_LWALL && player->collisionMode != CMODE_RWALL)
                canBreak = false;

            if (canBreak && !player->sidekick) {
                player->onGround = false;

                int32 sizeX = self->size.x;
                int32 sizeY = self->size.y;
                int32 posX  = self->position.x;
                int32 posY  = self->position.y;

                self->size.y = 1;
                self->position.y += 0x80000 - (sizeY << 19);

                BreakableWall_Break(self, FLIP_Y);

                self->size.x     = sizeX;
                self->size.y     = sizeY;
                self->position.x = posX;
                self->position.y = posY;
                RSDK.PlaySfx(BreakableWall->sfxBreak, false, 255);

                BreakableWall_GiveScoreBonus(player);

#if MANIA_USE_PLUS
                if (player->characterID == ID_MIGHTY && player->state == Player_State_MightyHammerDrop)
                    player->velocity.y = velY - TO_FIXED(1);
                else
#endif
                    player->velocity.y = 0;

                self->hitbox.top += 8;
                self->hitbox.bottom -= 8;
                --self->size.y;
                self->position.y += TO_FIXED(8);

                if (self->size.y <= 0)
                    destroyEntity(self);
            }
        }
    }
}
void BreakableWall_CheckBreak_BurrowFloorUp(void)
{
    RSDK_THIS(BreakableWall);

    foreach_active(Player, player)
    {
        int32 velY = player->velocity.y;
        if (Player_CheckCollisionBox(player, self, &self->hitbox) == C_BOTTOM) {
#if MANIA_USE_PLUS
            if (self->onlyMighty) {
                if ((player->characterID != ID_MIGHTY) && (!self->onlyKnux || player->characterID != ID_KNUCKLES))
                    continue;
            }
            else {
                if (self->onlyKnux && player->characterID != ID_KNUCKLES && (!self->onlyMighty || player->characterID != ID_MIGHTY))
                    continue;
            }
#else
            if (self->onlyKnux && player->characterID != ID_KNUCKLES)
                continue;
#endif

            if (!player->sidekick) {
                int32 sizeX = self->size.x;
                int32 sizeY = self->size.y;
                int32 posX  = self->position.x;
                int32 posY  = self->position.y;

                if (sizeY > 2)
                    self->size.y = 2;
                self->position.y += (sizeY - self->size.y) << 19;

                BreakableWall_Break(self, FLIP_Y);

                self->size.x     = sizeX;
                self->size.y     = sizeY;
                self->position.x = posX;
                self->position.y = posY;
                RSDK.PlaySfx(BreakableWall->sfxBreak, false, 255);

                player->velocity.y = 0;

                if (self->size.y < 2) {
                    self->hitbox.top += 8;
                    self->size.y -= 1;
                    self->hitbox.bottom -= 8;
                    self->position.y -= TO_FIXED(8);
                }
                else {
                    self->hitbox.top += 16;
                    self->size.y -= 2;
                    self->hitbox.bottom -= 16;
                    self->position.y -= TO_FIXED(16);
                }

                if (self->size.y <= 0)
                    destroyEntity(self);

                player->velocity.y = velY;
            }
        }
    }
}
void BreakableWall_CheckBreak_Ceiling(void)
{
    RSDK_THIS(BreakableWall);

    foreach_active(Player, player)
    {
        int32 velY = player->velocity.y;
        if (Player_CheckCollisionBox(player, self, &self->hitbox) == C_BOTTOM) {
#if MANIA_USE_PLUS
            if (self->onlyMighty) {
                if ((player->characterID != ID_MIGHTY) && (!self->onlyKnux || player->characterID != ID_KNUCKLES))
                    continue;
            }
            else {
                if (self->onlyKnux && player->characterID != ID_KNUCKLES && (!self->onlyMighty || player->characterID != ID_MIGHTY))
                    continue;
            }
#else
            if (self->onlyKnux && player->characterID != ID_KNUCKLES)
                continue;
#endif
            player->onGround = false;

            BreakableWall_Break(self, FLIP_Y);

            RSDK.PlaySfx(BreakableWall->sfxBreak, false, 0xFF);
            player->velocity.y = velY;
            destroyEntity(self);
        }
    }
}
void BreakableWall_Break(EntityBreakableWall *self, uint8 direction)
{
    int32 startX = self->position.x;
    int32 startY = self->position.y;
    int32 endX   = self->position.x - (self->size.x << 19) + TO_FIXED(8);
    int32 endY   = self->position.y - (self->size.y << 19) + TO_FIXED(8);

    switch (direction) {
        case FLIP_NONE: startX += self->size.x << 19; break;
        case FLIP_X: startX -= self->size.x << 19; break;
        case FLIP_Y: startY += self->size.y << 19; break;
        case FLIP_XY: startY -= self->size.y << 19; break;
        default: break;
    }

    int32 curY = endY - startY;
    for (int32 y = 0; y < self->size.y; ++y) {
        int32 curX   = endX - startX;
        int32 tileY  = (curY + startY) >> 20;
        int32 angleX = 2 * (endX - startX);

        for (int32 x = 0; x < self->size.x; ++x) {
            int32 tileX               = (curX + startX) >> 20;
            EntityBreakableWall *tile = CREATE_ENTITY(BreakableWall, INT_TO_VOID(BREAKWALL_TILE_FIXED), curX + startX, curY + startY);
            tile->tileInfo            = RSDK.GetTile(self->priority, tileX, tileY);
            tile->drawGroup           = self->drawGroup;

            switch (direction) {
                case FLIP_NONE:
                case FLIP_X: {
                    int32 angle  = RSDK.ATan2(angleX, curY);
                    int32 angle2 = 0;
                    if (abs(curX) > 0x80000) {
                        if (curX + startX >= startX)
                            angle2 = RSDK.ATan2(TO_FIXED(8), curY);
                        else
                            angle2 = RSDK.ATan2(-TO_FIXED(8), curY);
                    }
                    else {
                        angle2 = RSDK.ATan2(curX, curY);
                    }

                    tile->velocity.x = direction == FLIP_NONE ? -TO_FIXED(1) : TO_FIXED(1);
                    tile->velocity.y = TO_FIXED(1);
                    tile->velocity.x += 40 * (((self->size.y << 19) + 3 * abs(curX) - abs(curY)) >> 18) * RSDK.Cos256(angle);
                    tile->velocity.y += 32 * ((abs(curY) + abs(curX) + 2 * abs(curY)) >> 18) * RSDK.Sin256(angle2);
                    break;
                }

                case FLIP_Y: {
                    int32 angle    = RSDK.ATan2(angleX, curY);
                    int32 velocity = (abs(curX) + 3 * abs(curY)) >> 18;

                    tile->velocity.x += 40 * velocity * RSDK.Cos256(angle);
                    tile->velocity.y += 40 * velocity * RSDK.Sin256(angle);
                    break;
                }
            }

            RSDK.SetTile(self->priority, tileX, tileY, -1);
            if (self->drawGroup < Zone->objectDrawGroup[0]) {
                if (BreakableWall->farPlaneLayer != (uint16)-1)
                    RSDK.SetTile(BreakableWall->farPlaneLayer, tileX, tileY, -1);
            }

            curX += TO_FIXED(16);
            angleX += TO_FIXED(32);
        }

        curY += TO_FIXED(16);
    }
}

// Misc
void BreakableWall_GiveScoreBonus(EntityPlayer *player)
{
    RSDK_THIS(BreakableWall);

    EntityScoreBonus *scoreBonus = CREATE_ENTITY(ScoreBonus, NULL, self->position.x, self->position.y);
    scoreBonus->drawGroup        = Zone->objectDrawGroup[1];
    scoreBonus->animator.frameID = player->scoreBonus;

    switch (player->scoreBonus) {
        case 0: Player_GiveScore(player, 100); break;
        case 1: Player_GiveScore(player, 200); break;
        case 2: Player_GiveScore(player, 500); break;

        case 3:
        case 4:
        case 5:
        case 6:
        case 7:
        case 8:
        case 9:
        case 10:
        case 11:
        case 12:
        case 13:
        case 14: Player_GiveScore(player, 1000); break;

        case 15: Player_GiveScore(player, 10000); break;

        default: break;
    }

    if (player->scoreBonus < 15)
        player->scoreBonus++;
}

#if GAME_INCLUDE_EDITOR
void BreakableWall_EditorDraw(void)
{
    RSDK_THIS(BreakableWall);

    int32 sizeX = self->size.x;
    int32 sizeY = self->size.y;

    switch (self->type) {
        case BREAKWALL_TYPE_WALL:
            if (!sizeX) {
                sizeX = TO_FIXED(2);
                sizeY = TO_FIXED(4);
            }
            break;

        case BREAKWALL_TYPE_FLOOR:
            if (!sizeX) {
                sizeX = TO_FIXED(2);
                sizeY = TO_FIXED(2);
            }
            break;

        case BREAKWALL_TYPE_BURROWFLOOR:
        case BREAKWALL_TYPE_BURROWFLOOR_B:
            if (!sizeX)
                sizeX = TO_FIXED(2);
            break;

        case BREAKWALL_TYPE_BURROWFLOORUP:
            if (!sizeX)
                sizeX = TO_FIXED(2);
            break;

        case BREAKWALL_TYPE_CEILING:
            if (!sizeX) {
                sizeX = TO_FIXED(2);
                sizeY = TO_FIXED(2);
            }
            break;

        default: break;
    }

    sizeX <<= 4;
    sizeY <<= 4;

    Vector2 drawPos;
    drawPos.x = self->position.x - sizeX;
    drawPos.y = self->position.y - sizeY;

    DrawHelpers_DrawRectOutline(self->position.x, self->position.y, sizeX, sizeY, 0xFFFF00);

    drawPos.x += sizeX >> 1;
    drawPos.y += sizeY >> 1;

    self->direction = FLIP_NONE;
    RSDK.DrawSprite(&BreakableWall->animator, &drawPos, false);

    drawPos.x += sizeX;
    self->direction = FLIP_X;
    RSDK.DrawSprite(&BreakableWall->animator, &drawPos, false);

    drawPos.y += sizeY;
    self->direction = FLIP_XY;
    RSDK.DrawSprite(&BreakableWall->animator, &drawPos, false);

    drawPos.x -= sizeX;
    self->direction = FLIP_Y;
    RSDK.DrawSprite(&BreakableWall->animator, &drawPos, false);
}

void BreakableWall_EditorLoad(void)
{
    BreakableWall->aniFrames = RSDK.LoadSpriteAnimation("Global/TicMark.bin", SCOPE_STAGE);
    RSDK.SetSpriteAnimation(BreakableWall->aniFrames, 0, &BreakableWall->animator, true, 0);

    RSDK_ACTIVE_VAR(BreakableWall, type);
    RSDK_ENUM_VAR("Wall", BREAKWALL_TYPE_WALL);
    RSDK_ENUM_VAR("Floor", BREAKWALL_TYPE_FLOOR);
    RSDK_ENUM_VAR("Burrow Floor", BREAKWALL_TYPE_BURROWFLOOR);
    RSDK_ENUM_VAR("Burrow Floor (Plane B Only)", BREAKWALL_TYPE_BURROWFLOOR_B);
    RSDK_ENUM_VAR("Burrow Floor Up", BREAKWALL_TYPE_BURROWFLOORUP);
    RSDK_ENUM_VAR("Ceiling", BREAKWALL_TYPE_CEILING);

    RSDK_ACTIVE_VAR(BreakableWall, priority);
    RSDK_ENUM_VAR("FG High", BREAKWALL_PRIO_HIGH);
    RSDK_ENUM_VAR("FG Low", BREAKWALL_PRIO_LOW);
}
#endif

void BreakableWall_Serialize(void)
{
    RSDK_EDITABLE_VAR(BreakableWall, VAR_UINT8, type);
    RSDK_EDITABLE_VAR(BreakableWall, VAR_BOOL, onlyKnux);
    RSDK_EDITABLE_VAR(BreakableWall, VAR_BOOL, onlyMighty);
    RSDK_EDITABLE_VAR(BreakableWall, VAR_ENUM, priority);
    RSDK_EDITABLE_VAR(BreakableWall, VAR_VECTOR2, size);
}