KartReject.cc

#include "KartReject.hh"
 
#include "game/kart/KartDynamics.hh"
#include "game/kart/KartMove.hh"
#include "game/kart/KartParam.hh"
#include "game/kart/KartState.hh"
 
#include "game/field/CollisionDirector.hh"
#include "game/field/CourseColMgr.hh"
 
#include <egg/math/Math.hh>
#include <egg/math/Quat.hh>
 
namespace Kart {
 
KartReject::KartReject() = default;
 
KartReject::~KartReject() = default;
 
void KartReject::reset() {
    m_rejectSign = 0.0f;
}
 
void KartReject::calcRejectRoad() {
    auto &status = KartObjectProxy::status();
 
    if (status.onBit(eStatus::InAction)) {
        return;
    }
 
    if (status.onBit(eStatus::RejectRoadTrigger)) {
        EGG::Vector3f down = -EGG::Vector3f::ey;
        down = down.perpInPlane(move()->up(), true);
        f32 cos = down.dot(move()->lastDir());
        f32 sin = down.cross(move()->lastDir()).length();
        f32 angle = EGG::Mathf::atan2(sin, cos);
        angle = angle > 0.0f ? angle : -angle;
 
        f32 minAngle = 60.0f;
        angle *= RAD2DEG;
        f32 dVar11 = 1.0f;
 
        if (move()->up().dot(EGG::Vector3f::ey) < -0.7f) {
            minAngle *= 0.5f;
            dVar11 *= 2.0f;
        }
 
        if (angle > minAngle) {
            angle = 0.05f * (angle - 60.0f);
            EGG::Quatf rot = EGG::Quatf::FromRPY(0.0f,
                    (1.0f + angle * move()->speedRatio()) * dVar11 * DEG2RAD * m_rejectSign, 0.0f);
            EGG::Quatf local_78 = mainRot().multSwap(rot);
            local_78.normalise();
 
            dynamics()->setAngVel0(EGG::Vector3f::zero);
            dynamics()->setFullRot(local_78);
            dynamics()->setMainRot(local_78);
        }
 
        status.resetBit(eStatus::Hop);
 
        bool didReject = calcRejection();
 
        if (status.offBit(eStatus::NoSparkInvisibleWall) && !didReject) {
            move()->clearRejectRoad();
        }
 
        return;
    }
 
    if (status.onBit(eStatus::RejectRoad) &&
            status.offBit(eStatus::ZipperInvisibleWall, eStatus::OverZipper,
                    eStatus::HalfPipeRamp)) {
        EGG::Vector3f upXZ = move()->up();
        upXZ.y = 0.0f;
 
        if (upXZ.length() > 0.0f && speed() > 0.0f) {
            upXZ.normalise();
            EGG::Vector3f local_88 = move()->lastDir().perpInPlane(upXZ, true);
 
            if (local_88.y > 0.0f) {
                EGG::Vector3f upCross = EGG::Vector3f::ey.cross(local_88);
                m_rejectSign = upCross.dot(move()->up()) > 0.0f ? 1.0f : -1.0f;
 
                status.resetBit(eStatus::Hop).setBit(eStatus::RejectRoadTrigger);
            }
        }
    }
}
 
bool KartReject::calcRejection() {
    Field::CollisionInfo colInfo;
    Field::KCLTypeMask mask = KCL_NONE;
    auto &status = KartObjectProxy::status();
    status.resetBit(eStatus::NoSparkInvisibleWall);
    EGG::Vector3f worldUpPos = dynamics()->pos() + bodyUp() * 100.0f;
    f32 posScalar = 100.0f;
    f32 radius = posScalar;
 
    for (size_t i = 0; i < 2; ++i) {
        EGG::Vector3f local_d0 = dynamics()->mainRot().rotateVector(EGG::Vector3f::ey);
        EGG::Vector3f worldPos = pos() + (-posScalar * move()->scale().y) * local_d0;
 
        auto *colDir = Field::CollisionDirector::Instance();
        if (!colDir->checkSphereFullPush(radius, worldPos, worldUpPos, KCL_TYPE_B0E82DFF, &colInfo,
                    &mask, 0)) {
            if (i == 0) {
                posScalar = 0.0f;
            }
 
            continue;
        }
 
        EGG::Vector3f tangentOff = EGG::Vector3f::zero;
 
        if (!calcCollision(colInfo, mask, tangentOff)) {
            continue;
        }
 
        EGG::Vector3f tangentUp = (tangentOff - move()->up()) * 1.0f;
        move()->setUp(move()->up() + tangentUp);
        move()->setSmoothedUp(move()->up());
 
        bool bVar15 = tangentOff.dot(EGG::Vector3f::ey) < -0.17f;
        if (bVar15 || extVel().y < 0.0f || status.onBit(eStatus::NoSparkInvisibleWall)) {
            radius = -radius;
            colInfo.tangentOff += worldPos;
 
            f32 yOffset = bsp().initialYPos * scale().y;
            f32 speedScalar = bVar15 ?
                    1.0f :
                    static_cast<f32>(static_cast<f64>(EGG::Mathf::abs(speed()) * 0.01f) - 0.3d);
            speedScalar = std::min(1.0f, std::max(0.0f, speedScalar));
 
            EGG::Vector3f posOffset =
                    colInfo.tangentOff + radius * tangentOff + yOffset * tangentOff;
            posOffset.y += move()->hopPosY();
            posOffset -= pos();
            setPos(pos() + posOffset * speedScalar);
        }
 
        EGG::Vector3f local_13c = move()->lastDir().perpInPlane(move()->smoothedUp(), true);
        move()->setDir(local_13c);
        move()->setVel1Dir(local_13c);
 
        return true;
    }
 
    return false;
}
 
bool KartReject::calcCollision(Field::CollisionInfo &colInfo, Field::KCLTypeMask mask,
        EGG::Vector3f &tangentOff) {
    auto *colDir = Field::CollisionDirector::Instance();
 
    if (mask & KCL_TYPE_INVISIBLE_WALL) {
        if (colDir->findClosestCollisionEntry(&mask, KCL_TYPE_INVISIBLE_WALL) &&
                colDir->closestCollisionEntry()->variant() == 0) {
            tangentOff = colInfo.wallNrm;
            status().setBit(eStatus::NoSparkInvisibleWall);
            return true;
        }
    }
 
    Field::KCLTypeMask halfPipeInvisMask = KCL_TYPE_BIT(COL_TYPE_HALFPIPE_INVISIBLE_WALL);
    if (mask & halfPipeInvisMask) {
        if (colDir->findClosestCollisionEntry(&mask, halfPipeInvisMask)) {
            tangentOff = colInfo.wallNrm;
            status().setBit(eStatus::NoSparkInvisibleWall);
            return true;
        }
    }
 
    if (mask & KCL_TYPE_DRIVER_FLOOR) {
        if (colDir->findClosestCollisionEntry(&mask, KCL_TYPE_DRIVER_FLOOR) &&
                colDir->closestCollisionEntry()->attribute.onBit(
                        Field::CollisionDirector::eCollisionAttribute::RejectRoad)) {
            tangentOff = colInfo.floorNrm;
            return true;
        }
    }
 
    return false;
}
 
} // namespace Kart