KartObjectProxy.cc

#include "KartObjectProxy.hh"
 
#include "game/kart/CollisionGroup.hh"
#include "game/kart/KartObject.hh"
#include "game/kart/KartObjectManager.hh"
#include "game/kart/KartState.hh"
#include "game/kart/KartSub.hh"
#include "game/kart/KartSuspension.hh"
#include "game/kart/KartTire.hh"
 
#include "game/system/CourseMap.hh"
#include "game/system/RaceManager.hh"
#include "game/system/map/MapdataCannonPoint.hh"
 
#include <egg/math/Math.hh>
 
#include <algorithm>
 
namespace Kart {
 
KartObjectProxy::KartObjectProxy() : m_accessor(nullptr) {
    s_proxyList.push_back(this);
}
 
KartObjectProxy::~KartObjectProxy() = default;
 
void KartObjectProxy::setPos(const EGG::Vector3f &pos) {
    dynamics()->setPos(pos);
}
 
void KartObjectProxy::setRot(const EGG::Quatf &q) {
    dynamics()->setFullRot(q);
    dynamics()->setMainRot(q);
}
 
void KartObjectProxy::setInertiaScale(const EGG::Vector3f &scale) {
    const EGG::Vector3f *cuboids = bsp().cuboids;
    dynamics()->setInertia(cuboids[0] * scale, cuboids[1] * scale);
}
 
KartAction *KartObjectProxy::action() {
    return m_accessor->action;
}
 
const KartAction *KartObjectProxy::action() const {
    return m_accessor->action;
}
 
KartBody *KartObjectProxy::body() {
    return m_accessor->body;
}
 
const KartBody *KartObjectProxy::body() const {
    return m_accessor->body;
}
 
KartCollide *KartObjectProxy::collide() {
    return m_accessor->collide;
}
 
const KartCollide *KartObjectProxy::collide() const {
    return m_accessor->collide;
}
 
CollisionGroup *KartObjectProxy::collisionGroup() {
    return m_accessor->body->physics()->hitboxGroup();
}
 
const CollisionGroup *KartObjectProxy::collisionGroup() const {
    return m_accessor->body->physics()->hitboxGroup();
}
 
KartMove *KartObjectProxy::move() {
    return m_accessor->move;
}
 
const KartMove *KartObjectProxy::move() const {
    return m_accessor->move;
}
 
KartHalfPipe *KartObjectProxy::halfPipe() {
    return m_accessor->move->halfPipe();
}
 
const KartHalfPipe *KartObjectProxy::halfPipe() const {
    return m_accessor->move->halfPipe();
}
 
KartScale *KartObjectProxy::kartScale() {
    return m_accessor->move->kartScale();
}
 
const KartScale *KartObjectProxy::kartScale() const {
    return m_accessor->move->kartScale();
}
 
KartJump *KartObjectProxy::jump() {
    return m_accessor->move->jump();
}
 
const KartJump *KartObjectProxy::jump() const {
    return m_accessor->move->jump();
}
 
KartParam *KartObjectProxy::param() {
    return m_accessor->param;
}
 
const KartParam *KartObjectProxy::param() const {
    return m_accessor->param;
}
 
const BSP &KartObjectProxy::bsp() const {
    return param()->bsp();
}
 
KartPhysics *KartObjectProxy::physics() {
    return body()->physics();
}
 
const KartPhysics *KartObjectProxy::physics() const {
    return body()->physics();
}
 
KartDynamics *KartObjectProxy::dynamics() {
    return physics()->dynamics();
}
 
const KartDynamics *KartObjectProxy::dynamics() const {
    return physics()->dynamics();
}
 
KartState *KartObjectProxy::state() {
    return m_accessor->state;
}
 
const KartState *KartObjectProxy::state() const {
    return m_accessor->state;
}
 
KartSub *KartObjectProxy::sub() {
    return m_accessor->sub;
}
 
const KartSub *KartObjectProxy::sub() const {
    return m_accessor->sub;
}
 
KartSuspension *KartObjectProxy::suspension(u16 suspIdx) {
    return m_accessor->suspensions[suspIdx];
}
 
const KartSuspension *KartObjectProxy::suspension(u16 suspIdx) const {
    return m_accessor->suspensions[suspIdx];
}
 
KartSuspensionPhysics *KartObjectProxy::suspensionPhysics(u16 suspIdx) {
    return m_accessor->suspensions[suspIdx]->suspPhysics();
}
 
const KartSuspensionPhysics *KartObjectProxy::suspensionPhysics(u16 suspIdx) const {
    return m_accessor->suspensions[suspIdx]->suspPhysics();
}
 
KartTire *KartObjectProxy::tire(u16 tireIdx) {
    return m_accessor->tires[tireIdx];
}
 
const KartTire *KartObjectProxy::tire(u16 tireIdx) const {
    return m_accessor->tires[tireIdx];
}
 
WheelPhysics *KartObjectProxy::tirePhysics(u16 tireIdx) {
    return tire(tireIdx)->wheelPhysics();
}
 
const WheelPhysics *KartObjectProxy::tirePhysics(u16 tireIdx) const {
    return m_accessor->tires[tireIdx]->wheelPhysics();
}
 
CollisionData &KartObjectProxy::collisionData() {
    return physics()->hitboxGroup()->collisionData();
}
 
const CollisionData &KartObjectProxy::collisionData() const {
    return m_accessor->body->physics()->hitboxGroup()->collisionData();
}
 
const System::KPad *KartObjectProxy::inputs() const {
    return System::RaceManager::Instance()->player().inputs();
}
 
Render::KartModel *KartObjectProxy::model() {
    return m_accessor->model;
}
 
const Render::KartModel *KartObjectProxy::model() const {
    return m_accessor->model;
}
 
Field::ObjectCollisionKart *KartObjectProxy::objectCollisionKart() {
    return m_accessor->objectCollisionKart;
}
 
const Field::ObjectCollisionKart *KartObjectProxy::objectCollisionKart() const {
    return m_accessor->objectCollisionKart;
}
 
Field::BoxColUnit *KartObjectProxy::boxColUnit() {
    return m_accessor->boxColUnit;
}
 
const Field::BoxColUnit *KartObjectProxy::boxColUnit() const {
    return m_accessor->boxColUnit;
}
 
CollisionData &KartObjectProxy::collisionData(u16 tireIdx) {
    return tirePhysics(tireIdx)->hitboxGroup()->collisionData();
}
 
const CollisionData &KartObjectProxy::collisionData(u16 tireIdx) const {
    return m_accessor->tires[tireIdx]->wheelPhysics()->hitboxGroup()->collisionData();
}
 
const EGG::Vector3f &KartObjectProxy::scale() const {
    return move()->scale();
}
 
const EGG::Matrix34f &KartObjectProxy::pose() const {
    return physics()->pose();
}
 
EGG::Vector3f KartObjectProxy::bodyFront() const {
    const EGG::Matrix34f &mtx = pose();
    return EGG::Vector3f(mtx[0, 2], mtx[1, 2], mtx[2, 2]);
}
 
EGG::Vector3f KartObjectProxy::bodyForward() const {
    const EGG::Matrix34f &mtx = pose();
    return EGG::Vector3f(mtx[0, 0], mtx[1, 0], mtx[2, 0]);
}
 
EGG::Vector3f KartObjectProxy::bodyUp() const {
    const EGG::Matrix34f &mtx = pose();
    return EGG::Vector3f(mtx[0, 1], mtx[1, 1], mtx[2, 1]);
}
 
const EGG::Vector3f &KartObjectProxy::componentXAxis() const {
    return physics()->xAxis();
}
 
const EGG::Vector3f &KartObjectProxy::componentYAxis() const {
    return physics()->yAxis();
}
 
const EGG::Vector3f &KartObjectProxy::componentZAxis() const {
    return physics()->zAxis();
}
 
const EGG::Vector3f &KartObjectProxy::pos() const {
    return dynamics()->pos();
}
 
const EGG::Vector3f &KartObjectProxy::prevPos() const {
    return physics()->pos();
}
 
const EGG::Quatf &KartObjectProxy::fullRot() const {
    return dynamics()->fullRot();
}
 
const EGG::Vector3f &KartObjectProxy::extVel() const {
    return dynamics()->extVel();
}
 
const EGG::Vector3f &KartObjectProxy::intVel() const {
    return dynamics()->intVel();
}
 
const EGG::Vector3f &KartObjectProxy::velocity() const {
    return dynamics()->velocity();
}
 
f32 KartObjectProxy::speed() const {
    return move()->speed();
}
 
f32 KartObjectProxy::acceleration() const {
    return move()->acceleration();
}
 
f32 KartObjectProxy::softSpeedLimit() const {
    return move()->softSpeedLimit();
}
 
const EGG::Quatf &KartObjectProxy::mainRot() const {
    return dynamics()->mainRot();
}
 
const EGG::Vector3f &KartObjectProxy::angVel2() const {
    return dynamics()->angVel2();
}
 
bool KartObjectProxy::isBike() const {
    return param()->isBike();
}
 
u16 KartObjectProxy::suspCount() const {
    return param()->suspCount();
}
 
u16 KartObjectProxy::tireCount() const {
    return param()->tireCount();
}
 
bool KartObjectProxy::hasFloorCollision(const WheelPhysics *wheelPhysics) const {
    return wheelPhysics->hitboxGroup()->collisionData().bFloor;
}
 
std::pair<EGG::Vector3f, EGG::Vector3f> KartObjectProxy::getCannonPosRot() {
    auto *cannon = System::CourseMap::Instance()->getCannonPoint(state()->cannonPointId());
    const EGG::Vector3f &cannonPos = cannon->pos();
    EGG::Vector3f cannonRot = cannon->rot();
    EGG::Vector3f radRot = cannon->rot() * DEG2RAD;
    EGG::Matrix34f rotMat;
    rotMat.makeR(radRot);
    cannonRot = rotMat.multVector33(EGG::Vector3f::ez);
    EGG::Vector3f distance_to_cannon = this->pos() - cannonPos;
    distance_to_cannon.y = 0.0f;
    EGG::Vector3f local60 = EGG::Vector3f::ey.cross(cannonRot);
    f32 temp0 = local60.dot(distance_to_cannon);
    return std::pair(cannonPos + local60 * temp0, cannonRot);
}
 
f32 KartObjectProxy::speedRatio() const {
    return move()->speedRatio();
}
 
f32 KartObjectProxy::speedRatioCapped() const {
    return move()->speedRatioCapped();
}
 
bool KartObjectProxy::isInRespawn() const {
    return move()->respawnTimer() > 0 || move()->respawnPostLandTimer() > 0;
}
 
Field::KCLTypeMask KartObjectProxy::wallKclType() const {
    return collisionData().closestWallFlags;
}
 
u32 KartObjectProxy::wallKclVariant() const {
    return collisionData().closestWallSettings;
}
 
void KartObjectProxy::apply(size_t idx) {
    m_accessor = KartObjectManager::Instance()->object(idx)->accessor();
}
 
void KartObjectProxy::ApplyAll(const KartAccessor *pointers) {
    for (auto iter = s_proxyList.begin(); iter != s_proxyList.end(); ++iter) {
        (*iter)->m_accessor = pointers;
    }
}
 
std::list<KartObjectProxy *> KartObjectProxy::s_proxyList; 
 
} // namespace Kart