act3ammo.cpp

Go to the documentation of this file.

#include "act3ammo.h"
 
#include "act3.h"
#include "act3actors.h"
#include "legocachesoundmanager.h"
#include "legocharactermanager.h"
#include "legopathboundary.h"
#include "legopathcontroller.h"
#include "legosoundmanager.h"
#include "misc.h"
#include "roi/legoroi.h"
 
#include <assert.h>
#include <stdio.h>
 
DECOMP_SIZE_ASSERT(Act3Ammo, 0x1a0)
 
// Initialized at LEGO1 0x100537c0
// GLOBAL: LEGO1 0x10104f08
Mx3DPointFloat Act3Ammo::g_unk0x10104f08 = Mx3DPointFloat(0.0, 5.0, 0.0);
 
// FUNCTION: LEGO1 0x100537f0
// FUNCTION: BETA10 0x1001d648
Act3Ammo::Act3Ammo()
{
    m_ammoFlag = 0;
    m_world = NULL;
}
 
// FUNCTION: LEGO1 0x100538a0
// FUNCTION: BETA10 0x1001d6e7
Act3Ammo::~Act3Ammo()
{
    Destroy(TRUE);
}
 
// FUNCTION: LEGO1 0x10053900
// FUNCTION: BETA10 0x1001d759
void Act3Ammo::Destroy(MxBool p_fromDestructor)
{
    if (!p_fromDestructor) {
        assert(0);
    }
    else if (m_roi != NULL) {
        CharacterManager()->ReleaseActor(m_roi->GetName());
        m_roi = NULL;
    }
}
 
// FUNCTION: LEGO1 0x10053930
// FUNCTION: BETA10 0x1001d7d0
MxResult Act3Ammo::Remove()
{
    assert(IsValid());
    assert(m_roi && m_pathController);
 
    CharacterManager()->ReleaseActor(m_roi->GetName());
    m_roi = NULL;
 
    if (m_boundary != NULL) {
        m_boundary->RemoveActor(this);
    }
 
    m_pathController->RemoveActor(this);
    m_ammoFlag = 0;
    return SUCCESS;
}
 
// FUNCTION: LEGO1 0x10053980
// FUNCTION: BETA10 0x1001d8b3
MxResult Act3Ammo::Create(Act3* p_world, MxU32 p_isPizza, MxS32 p_index)
{
    assert(m_ammoFlag);
    char name[12];
 
    if (p_isPizza) {
        sprintf(name, "pammo%d", p_index);
        m_roi = CharacterManager()->CreateAutoROI(name, "pizpie", FALSE);
        m_roi->SetVisibility(TRUE);
 
        BoundingSphere sphere;
 
        sphere.Center()[0] = sphere.Center()[1] = sphere.Center()[2] = 0.0f;
        sphere.Radius() = m_roi->GetBoundingSphere().Radius() * 2.0f;
        m_roi->SetBoundingSphere(sphere);
 
        m_ammoFlag = c_pizza;
        assert(m_roi);
    }
    else {
        sprintf(name, "dammo%d", p_index);
        m_roi = CharacterManager()->CreateAutoROI(name, "donut", FALSE);
        m_roi->SetVisibility(TRUE);
 
        BoundingSphere sphere;
 
        sphere.Center()[0] = sphere.Center()[1] = sphere.Center()[2] = 0.0f;
        sphere.Radius() = m_roi->GetBoundingSphere().Radius() * 5.0f;
        m_roi->SetBoundingSphere(sphere);
 
        m_ammoFlag = c_donut;
        assert(m_roi);
    }
 
    m_world = p_world;
    SetValid(TRUE);
    return SUCCESS;
}
 
// FUNCTION: LEGO1 0x10053b40
// FUNCTION: BETA10 0x1001db2a
MxResult Act3Ammo::FUN_10053b40(const Vector3& p_srcLoc, const Vector3& p_srcDir, const Vector3& p_srcUp)
{
    assert(p_srcDir[1] != 0);
 
    MxFloat local1c = -(p_srcLoc[1] / p_srcDir[1]);
    Mx3DPointFloat local18(p_srcDir);
    Mx3DPointFloat local34;
 
    local18 *= local1c;
    local18 += p_srcLoc;
 
    local34[0] = local34[2] = 0.0f;
    local34[1] = -1.0f;
 
    m_eq[1] = p_srcUp;
    m_eq[2] = p_srcLoc;
 
    Mx3DPointFloat local48(local34);
    local48 -= m_eq[1];
 
    for (MxS32 i = 0; i < 3; i++) {
        if (local18[0] == p_srcLoc[0]) {
            return FAILURE;
        }
 
        m_eq[0][i] = (local48[i] * local48[i] + local48[i] * m_eq[1][i] * 2.0f) / ((local18[i] - p_srcLoc[i]) * 4.0f);
    }
 
    assert(m_eq[0][0] > 0.000001 || m_eq[0][0] < -0.000001);
 
    m_unk0x19c = local48[0] / (m_eq[0][0] * 2.0f);
    return SUCCESS;
}
 
// FUNCTION: LEGO1 0x10053cb0
// FUNCTION: BETA10 0x1001ddf4
MxResult Act3Ammo::FUN_10053cb0(LegoPathController* p_p, LegoPathBoundary* p_boundary, MxFloat p_unk0x19c)
{
    assert(p_p);
    assert(IsValid());
 
    if (IsPizza()) {
        assert(SoundManager()->GetCacheSoundManager());
        SoundManager()->GetCacheSoundManager()->Play("shootpz", NULL, FALSE);
    }
    else {
        assert(SoundManager()->GetCacheSoundManager());
        SoundManager()->GetCacheSoundManager()->Play("shootdn", NULL, FALSE);
    }
 
    m_pathController = p_p;
    m_boundary = p_boundary;
    m_BADuration = 10000.0f;
    m_unk0x19c = p_unk0x19c;
    m_unk0x7c = 0.0f;
    m_lastTime = -1.0f;
    m_actorState = c_one;
    return SUCCESS;
}
 
// FUNCTION: LEGO1 0x10053d30
// FUNCTION: BETA10 0x1001df73
MxResult Act3Ammo::FUN_10053d30(LegoPathController* p_p, MxFloat p_unk0x19c)
{
    assert(p_p);
    assert(IsValid());
 
    SetBit4(TRUE);
 
    if (IsPizza()) {
        assert(SoundManager()->GetCacheSoundManager());
        SoundManager()->GetCacheSoundManager()->Play("shootpz", NULL, FALSE);
    }
    else {
        assert(SoundManager()->GetCacheSoundManager());
        SoundManager()->GetCacheSoundManager()->Play("shootdn", NULL, FALSE);
    }
 
    m_pathController = p_p;
    m_BADuration = 10000.0f;
    m_unk0x19c = p_unk0x19c;
    m_unk0x7c = 0.0f;
    m_lastTime = -1.0f;
    m_actorState = c_one;
    return SUCCESS;
}
 
// FUNCTION: LEGO1 0x10053db0
// FUNCTION: BETA10 0x1001e0f0
MxResult Act3Ammo::FUN_10053db0(float p_param1, const Matrix4& p_param2)
{
    float local34 = p_param1 * p_param1;
 
    Vector3 local14(p_param2[0]);
    Vector3 local3c(p_param2[1]);
    Vector3 localc(p_param2[2]);
    Vector3 local30(p_param2[3]);
    Mx3DPointFloat local28;
 
    local28 = m_eq[1];
    local28 *= p_param1;
    local30 = m_eq[0];
    local30 *= local34;
    local30 += local28;
    local30 += m_eq[2];
    localc = m_eq[0];
    localc *= 2.0f;
    localc *= p_param1;
    localc += m_eq[1];
    localc *= -1.0f;
 
    if (localc.Unitize() != 0) {
        assert(0);
        return FAILURE;
    }
 
    local14[1] = local14[2] = 0.0f;
    local14[0] = 1.0f;
    local3c.EqualsCross(localc, local14);
 
    if (local3c.Unitize() != 0) {
        local14[0] = local14[1] = 0.0f;
        local14[2] = 1.0f;
        local3c.EqualsCross(localc, local14);
 
        if (local3c.Unitize() != 0) {
            assert(0);
            return FAILURE;
        }
    }
 
    local14.EqualsCross(local3c, localc);
    return SUCCESS;
}
 
// FUNCTION: LEGO1 0x10054050
// FUNCTION: BETA10 0x1001e362
void Act3Ammo::Animate(float p_time)
{
    assert(IsValid());
 
    switch (m_actorState & c_maxState) {
    case c_initial:
    case c_one:
        break;
    case c_two:
        m_unk0x158 = p_time + 2000.0f;
        m_actorState = c_three;
        return;
    case c_three:
        MxMatrix transform;
        Vector3 positionRef(transform[3]);
 
        transform = m_roi->GetLocal2World();
 
        if (m_unk0x158 > p_time) {
            Mx3DPointFloat position;
 
            position = positionRef;
            positionRef.Clear();
            transform.RotateX(0.6);
            positionRef = position;
            m_roi->FUN_100a58f0(transform);
            m_roi->VTable0x14();
            return;
        }
        else {
            m_actorState = c_initial;
            m_unk0x158 = 0;
 
            positionRef -= g_unk0x10104f08;
            m_roi->FUN_100a58f0(transform);
            m_roi->VTable0x14();
            return;
        }
    }
 
    if (m_worldSpeed <= 0.0f) {
        return;
    }
 
    if (m_lastTime < 0.0f) {
        m_lastTime = p_time;
        m_unk0x7c = 0.0f;
    }
 
    MxMatrix local104;
    MxMatrix local60;
 
    float f = (m_BADuration - m_unk0x7c) / m_worldSpeed + m_lastTime;
 
    undefined4 localb4 = 0;
    undefined4 localbc = 0;
    MxU32 local14 = FALSE;
    MxU32 localb8 = FALSE;
 
    if (f >= p_time) {
        m_actorTime = (p_time - m_lastTime) * m_worldSpeed + m_actorTime;
        m_unk0x7c = (p_time - m_lastTime) * m_worldSpeed + m_unk0x7c;
        m_lastTime = p_time;
    }
    else {
        localb8 = TRUE;
        m_unk0x7c = m_BADuration;
        m_lastTime = p_time;
    }
 
    local104.SetIdentity();
 
    MxResult r = FUN_10053db0((m_unk0x7c / m_BADuration) * m_unk0x19c, local104);
    assert(r == 0); // SUCCESS
 
    local60.SetIdentity();
 
    if (IsPizza()) {
        local60.Scale(2.0f, 2.0f, 2.0f);
    }
    else {
        local60.Scale(5.0f, 5.0f, 5.0f);
    }
 
    if (localb8) {
        if (m_boundary != NULL) {
            Vector3 local17c(local104[0]);
            Vector3 local184(local104[1]);
            Vector3 local174(local104[2]);
 
            if (IsPizza()) {
                local184 = *m_boundary->GetUnknown0x14();
                local17c[0] = 1.0f;
                local17c[1] = local17c[2] = 0.0f;
                local174.EqualsCross(local17c, local184);
                local174.Unitize();
                local17c.EqualsCross(local184, local174);
            }
            else {
                local17c = *m_boundary->GetUnknown0x14();
                local184[0] = 1.0f;
                local184[1] = local184[2] = 0.0f;
                local174.EqualsCross(local17c, local184);
                local174.Unitize();
                local184.EqualsCross(local174, local17c);
            }
        }
 
        m_actorState = c_initial;
    }
    else {
        local60.RotateX(m_actorTime / 10.0f);
        local60.RotateY(m_actorTime / 6.0f);
    }
 
    MxMatrix localb0(local104);
    local104.Product(local60, localb0);
    m_roi->FUN_100a58f0(local104);
    m_roi->VTable0x14();
 
    if (m_BADuration <= m_unk0x7c) {
        m_worldSpeed = 0.0f;
    }
 
    Vector3 local68(local104[3]);
 
    if (localb8) {
        if (IsBit4()) {
            if (IsPizza()) {
                m_world->RemovePizza(*this);
                m_world->FUN_10072ad0(2);
            }
            else {
                m_world->RemoveDonut(*this);
                m_world->FUN_10072ad0(4);
            }
        }
        else {
            if (IsPizza()) {
                assert(SoundManager()->GetCacheSoundManager());
                SoundManager()->GetCacheSoundManager()->Play("stickpz", NULL, FALSE);
            }
            else {
                assert(SoundManager()->GetCacheSoundManager());
                SoundManager()->GetCacheSoundManager()->Play("stickdn", NULL, FALSE);
            }
 
            LegoPathActorSet& plpas = m_boundary->GetActors();
            LegoPathActorSet lpas(plpas);
 
            for (LegoPathActorSet::iterator itpa = lpas.begin(); itpa != lpas.end(); itpa++) {
                if (plpas.find(*itpa) != plpas.end() && this != *itpa) {
                    LegoROI* r = (*itpa)->GetROI();
                    assert(r);
 
                    if (!strncmp(r->GetName(), "pammo", 5)) {
                        Mx3DPointFloat local1c8;
                        Mx3DPointFloat local1b4;
 
                        local1c8 = r->GetLocal2World()[3];
                        local1b4 = m_roi->GetLocal2World()[3];
 
                        local1b4 -= local1c8;
 
                        float radius = r->GetWorldBoundingSphere().Radius();
                        if (local1b4.LenSquared() <= radius * radius) {
                            MxS32 index = -1;
                            if (sscanf(r->GetName(), "pammo%d", &index) != 1) {
                                assert(0);
                            }
 
                            assert(m_world);
 
                            if (m_world->m_pizzas[index].IsValid() && !m_world->m_pizzas[index].IsSharkFood()) {
                                m_world->EatPizza(index);
                                m_world->m_brickster->FUN_100417c0();
                            }
 
                            if (IsDonut()) {
                                assert(SoundManager()->GetCacheSoundManager());
                                SoundManager()->GetCacheSoundManager()->Play("dnhitpz", NULL, FALSE);
                                m_world->RemoveDonut(*this);
                                local14 = TRUE;
                                break;
                            }
                        }
                    }
                    else if (!strncmp(r->GetName(), "dammo", 5)) {
                        Mx3DPointFloat local1f8;
                        Mx3DPointFloat local1e4;
 
                        local1f8 = r->GetLocal2World()[3];
                        local1e4 = m_roi->GetLocal2World()[3];
 
                        local1e4 -= local1f8;
 
                        float radius = r->GetWorldBoundingSphere().Radius();
                        if (local1e4.LenSquared() <= radius * radius) {
                            MxS32 index = -1;
                            if (sscanf(r->GetName(), "dammo%d", &index) != 1) {
                                assert(0);
                            }
 
                            assert(m_world);
 
                            m_world->EatDonut(index);
 
                            if (IsPizza()) {
                                assert(SoundManager()->GetCacheSoundManager());
                                SoundManager()->GetCacheSoundManager()->Play("pzhitdn", NULL, FALSE);
                                m_world->RemovePizza(*this);
                                local14 = TRUE;
                                break;
                            }
                        }
                    }
                }
            }
 
            if (!local14) {
                if (IsPizza()) {
                    m_world->FUN_10073360(*this, local68);
                }
                else {
                    m_world->FUN_10073390(*this, local68);
                }
 
                m_worldSpeed = -1.0f;
            }
        }
    }
}