TombEngine/TR5Main/Objects/TR4/Object/tr4_element_puzzle.cpp

#include "framework.h"
#include "tr4_element_puzzle.h"
#include "Specific/level.h"
#include "Game/control/control.h"
#include "Sound/sound.h"
#include "Game/animation.h"
#include "Game/Lara/lara.h"
#include "Game/Lara/lara_helpers.h"
#include "Game/collision/sphere.h"
#include "Game/effects/effects.h"
#include "Game/effects/tomb4fx.h"
#include "Specific/input.h"
#include "Objects/Generic/Switches/generic_switch.h"
#include "Game/collision/collide_room.h"
#include "Game/collision/collide_item.h"
#include "Game/items.h"

using namespace TEN::Entities::Switches;

namespace TEN::Entities::TR4
{
    OBJECT_COLLISION_BOUNDS ElementPuzzleBounds =
    {
        0, 0, 
        -64, 0, 
        0, 0,
        -ANGLE(10.0f), ANGLE(10.0f),
        -ANGLE(30.0f), ANGLE(30.0f),
        -ANGLE(10.0f), ANGLE(10.0f)
    };

    void ElementPuzzleControl(short itemNumber)
    {
        auto* item = &g_Level.Items[itemNumber];

        if (!TriggerActive(item))
            return;

        if (item->TriggerFlags == 1)
        {
            SoundEffect(SFX_TR4_LOOP_FOR_SMALL_FIRES, &item->Position, 0);

            byte r = (GetRandomControl() & 0x3F) + 192;
            byte g = (GetRandomControl() & 0x1F) + 96;
            byte b = 0;
            int on = 0;

            if (item->ItemFlags[3])
            {
                item->ItemFlags[3]--;
                on = 255 - GetRandomControl() % (4 * (91 - item->ItemFlags[3]));
                if (on < 1)
                {
                    on = 1;
                    r = (r * on) / 256;
                    g = (g * on) / 256;
                }
                else if (on <= 255)
                {
                    r = (r * on) / 256;
                    g = (g * on) / 256;
                }
            }
            else
                on = 0;

            AddFire(item->Position.xPos, item->Position.yPos - 620, item->Position.zPos, 1, item->RoomNumber, on);
            TriggerDynamicLight(item->Position.xPos, item->Position.yPos - 768, item->Position.zPos, 12, r, g, b);
            return;
        }

        if (item->TriggerFlags != 3)
            return;

        if (item->ItemFlags[1] > 90)
            SoundEffect(SFX_TR4_JOBY_WIND, &item->Position, 0);

        if (item->ItemFlags[1] < 60)
        {
            item->ItemFlags[1]++;
            return;
        }

        item->ItemFlags[0]++;

        if (item->ItemFlags[0] == 90)
        {
            short itemNos[256];
            int sw = GetSwitchTrigger(item, itemNos, 0);
            if (sw > 0)
            {
                for (int i = 0; i < sw; i++)
                {
                    AddActiveItem(itemNos[i]);
                    g_Level.Items[itemNos[i]].Status = ITEM_ACTIVE;
                    g_Level.Items[itemNos[i]].Flags |= 0x3E00;
                }
            }

            KillItem(itemNumber);
            return;
        }

        short currentItemNumber = g_Level.Rooms[item->RoomNumber].itemNumber;
        if (currentItemNumber == NO_ITEM)
            return;

        while (currentItemNumber != NO_ITEM)
        {
            auto* currentItem = &g_Level.Items[currentItemNumber];

            if (currentItem->ObjectNumber != ID_FLAME_EMITTER2)
            {
                if (currentItem->ObjectNumber == ID_ELEMENT_PUZZLE &&
                    currentItem->TriggerFlags == 1 &&
                    !currentItem->ItemFlags[3])
                {
                    currentItem->ItemFlags[3] = 90;
                }

                currentItemNumber = currentItem->NextItem;
                continue;
            }

            if (item->ItemFlags[0] != 89)
            {
                currentItem->ItemFlags[3] = 255 - GetRandomControl() % (4 * item->ItemFlags[0]);
                if (currentItem->ItemFlags[3] >= 2)
                {
                    currentItemNumber = currentItem->NextItem;
                    continue;
                }

                currentItem->ItemFlags[3] = 2;
            }

            RemoveActiveItem(currentItemNumber);
            currentItem->Status = ITEM_NOT_ACTIVE;
        }
    }

    void ElementPuzzleDoCollision(short itemNumber, ITEM_INFO* laraItem, COLL_INFO* coll)
    {
        auto* item = &g_Level.Items[itemNumber];

        if (TestBoundsCollide(item, laraItem, coll->Setup.Radius))
        {
            if (TestCollision(item, laraItem))
            {
                if (coll->Setup.EnableObjectPush)
                    ItemPushItem(item, laraItem, coll, 0, 0);
            }
        }
    }

    void ElementPuzzleCollision(short itemNumber, ITEM_INFO* laraItem, COLL_INFO* coll)
    {
        auto* laraInfo = GetLaraInfo(laraItem);
        auto* puzzleItem = &g_Level.Items[itemNumber];

        int flags = 0;

        if (puzzleItem->TriggerFlags)
        {
            if (puzzleItem->TriggerFlags == 1)
                flags = 26;
            else
            {
                if (puzzleItem->TriggerFlags != 2)
                    return;
             
                flags = 27;
            }
        }
        else
            flags = 25;

        if ((laraItem->AnimNumber == LA_WATERSKIN_POUR_LOW ||
            laraItem->AnimNumber == LA_WATERSKIN_POUR_HIGH) &&
            !puzzleItem->ItemFlags[0])
        {
            auto* box = GetBoundsAccurate(puzzleItem);

            ElementPuzzleBounds.boundingBox.X1 = box->X1;
            ElementPuzzleBounds.boundingBox.X2 = box->X2;
            ElementPuzzleBounds.boundingBox.Z1 = box->Z1 - 200;
            ElementPuzzleBounds.boundingBox.Z2 = box->Z2 + 200;

            short oldRot = puzzleItem->Position.yRot;
            puzzleItem->Position.yRot = laraItem->Position.yRot;

            if (TestLaraPosition(&ElementPuzzleBounds, puzzleItem, laraItem))
            {
                if (laraItem->AnimNumber == LA_WATERSKIN_POUR_LOW && LaraItem->ItemFlags[2] == flags)
                {
                    laraItem->AnimNumber = LA_WATERSKIN_POUR_HIGH;
                    laraItem->FrameNumber = g_Level.Anims[laraItem->AnimNumber].frameBase;
                }

                if (laraItem->FrameNumber == g_Level.Anims[LA_WATERSKIN_POUR_HIGH].frameBase + 74 &&
                    LaraItem->ItemFlags[2] == flags)
                {
                    if (!puzzleItem->TriggerFlags)
                    {
                        puzzleItem->MeshBits = 48;
                        TestTriggers(puzzleItem, true, puzzleItem->Flags & IFLAG_ACTIVATION_MASK);
                        puzzleItem->ItemFlags[0] = 1;
                        puzzleItem->Position.yRot = oldRot;
                        return;
                    }

                    if (puzzleItem->TriggerFlags == 1)
                    {
                        puzzleItem->MeshBits = 3;
                        laraInfo->Pickups[1]--;
                        puzzleItem->ItemFlags[0] = 1;
                        puzzleItem->Position.yRot = oldRot;
                        return;
                    }

                    puzzleItem->MeshBits = 12;
                    TestTriggers(puzzleItem, true, puzzleItem->Flags & IFLAG_ACTIVATION_MASK);
                    laraInfo->Pickups[0]--;
                    puzzleItem->ItemFlags[0] = 1;
                }
            }

            puzzleItem->Position.yRot = oldRot;
        }
        else
        {
            if (laraInfo->Control.Weapon.GunType != WEAPON_TORCH ||
                laraInfo->Control.HandStatus != HandStatus::WeaponReady ||
                laraInfo->LeftArm.Locked ||
                !(TrInput & IN_ACTION) ||
                puzzleItem->TriggerFlags != 1 ||
                puzzleItem->ItemFlags[0] != 1 ||
                laraItem->ActiveState != LS_IDLE ||
                laraItem->AnimNumber != LA_STAND_IDLE ||
                !laraInfo->LitTorch ||
                laraItem->Airborne)
            {
                if (laraItem->AnimNumber != LA_TORCH_LIGHT_3 ||
                    g_Level.Anims[LA_TORCH_LIGHT_3].frameBase + 16 ||
                    puzzleItem->ItemFlags[0] != 2)
                {
                    ElementPuzzleDoCollision(itemNumber, laraItem, coll);
                }
                else
                {
                    TestTriggers(puzzleItem, true, puzzleItem->Flags & IFLAG_ACTIVATION_MASK);
                    AddActiveItem(itemNumber);
                    puzzleItem->Status = ITEM_ACTIVE;
                    puzzleItem->ItemFlags[0] = 3;
                    puzzleItem->Flags |= 0x3E00;
                }
            }
            else
            {
                auto* box = GetBoundsAccurate(puzzleItem);

                ElementPuzzleBounds.boundingBox.X1 = box->X1;
                ElementPuzzleBounds.boundingBox.X2 = box->X2;
                ElementPuzzleBounds.boundingBox.Z1 = box->Z1 - 200;
                ElementPuzzleBounds.boundingBox.Z2 = box->Z2 + 200;

                short oldRot = puzzleItem->Position.yRot;
                puzzleItem->Position.yRot = laraItem->Position.yRot;

                if (TestLaraPosition(&ElementPuzzleBounds, puzzleItem, laraItem))
                {
                    laraItem->AnimNumber = (abs(puzzleItem->Position.yPos - laraItem->Position.yPos) >> 8) + LA_TORCH_LIGHT_3;
                    laraItem->FrameNumber = g_Level.Anims[puzzleItem->AnimNumber].frameBase;
                    laraItem->ActiveState = LS_MISC_CONTROL;
                    laraInfo->Flare.ControlLeft = false;
                    laraInfo->LeftArm.Locked = true;
                    puzzleItem->ItemFlags[0] = 2;
                }

                puzzleItem->Position.yRot = oldRot;
            }
        }
    }

    void InitialiseElementPuzzle(short itemNumber)
    {
        auto* item = &g_Level.Items[itemNumber];

        if (item->TriggerFlags)
        {
            if (item->TriggerFlags == 1)
                item->MeshBits = 65;
            else if (item->TriggerFlags == 2)
                item->MeshBits = 68;
            else
                item->MeshBits = 0;
        }
        else
            item->MeshBits = 80;
    }
}