d_cc.hpp

#pragma once
#include <types.h>
#include <game/bases/d_actor.hpp>
 
class dCc_c {
public:
    enum CC_SHAPE_e {
        CC_SHAPE_BOX, 
        CC_SHAPE_CIRCLE, 
        CC_SHAPE_DAIKEI_UD, 
        CC_SHAPE_DAIKEI_LR, 
    };
 
    enum CC_DATA_FLAG_e {
        CC_DATA_NO_OFFSET = 1, 
        CC_DATA_PASSIVE = 4
    };
 
    enum CC_FLAG_e {
        CC_DISABLE = 2, 
    };
 
    enum CC_CATEGORY_e {
        CAT_PLAYER_GENERIC,
        CAT_PLAYER_ATTACK,
        CAT_YOSHI,
        CAT_ENTITY,
        CAT_BALLOON,
        CAT_ITEM,
        CAT_PROJECTILE,
        CAT_CANNON,
        CAT_GOAL_POLE
    };
 
    enum CC_ATTACK_e {
        ATTACK_FIRE = 1,
        ATTACK_ICE,
        ATTACK_STAR,
        ATTACK_ICE_BREAK,
        ATTACK_SLIP,
        ATTACK_KOOPA_FIRE,
        ATTACK_HIP_ATTK,
        ATTACK_WIRE_NET,
        ATTACK_SHELL,
        ATTACK_PENGUIN_SLIDE,
        ATTACK_SPIN,
        ATTACK_UNK12,
        ATTACK_SPIN_FALL,
        ATTACK_FIRE_2,
        ATTACK_YOSHI_EAT,
        ATTACK_YOSHI_MOUTH,
        ATTACK_CANNON,
        ATTACK_YOSHI_BULLET,
        ATTACK_YOSHI_FIRE,
        ATTACK_ICE_2,
        ATTACK_SAND_PILLAR
    };
 
    struct CcData_s {
        float mOffsetX; 
        float mOffsetY; 
 
        float mWidth;
 
        float mHeight;
 
        u8 mCategory; 
        u8 mAttackCategory; 
        u32 mCategoryInteract;
        u32 mAttackCategoryInteract;
 
        u16 mFlag; 
 
        void (*mCallback)(dCc_c *, dCc_c *); 
    };
 
private:
 
    // [Some unused class - but needed here because it has a static initializer.]
    class InitializedUnkClass {
    public:
        u32 a, b, c;
        bool d, e;
 
        static class _init {
        public:
            _init() {
                if (!dCc_c::msIsInitialized) {
                    dCc_c::msInitializedUnkClass.b = 0xa000a0;
                    dCc_c::msInitializedUnkClass.c = 0xa00000a0;
                    dCc_c::msIsInitialized = true;
                }
            }
        } _initializer;
    };
    static char msIsInitialized; // [This might also be an auto-generated guard variable]
    static InitializedUnkClass msInitializedUnkClass;
 
public:
    dCc_c(); 
    virtual ~dCc_c(); 
 
    void clear(); 
 
    void entry(); 
    void release(); 
 
    void registerCc(dActor_c *actor, CcData_s *collInfo);
 
    void registerCc(dActor_c *actor, CcData_s *collInfo, u8 nonCollideMask);
 
    void setFriendActor(dActor_c *actor) { mFriendActor = actor; }
 
    u16 isHit(u16 mask) const;
 
    u16 isHitAtDmg(u16 mask) const;
 
    float getTopPos(); 
    float getUnderPos(); 
    float getCenterPosY(); 
 
    float getRightPos(); 
    float getLeftPos(); 
    float getCenterPosX(); 
 
    inline mVec2_c getCenterVec() {
        return mVec2_c(getCenterPosX(), getCenterPosY());
    }
 
    bool isInside(dCc_c *other);
 
private:
    float getTrpOffset(int idx) {
        return mTrpOffsets[idx];
    }
 
public:
    static bool checkCollision(dCc_c *c1, dCc_c *c2, int active);
 
    static void execute(); 
 
    static void reset();
 
private:
    static bool _hitCheckSquare(dCc_c *c1, dCc_c *c2, mVec2_c pos1, mVec2_c pos2);
 
    static bool _hitCheckNormal(dCc_c *c1, dCc_c *c2);
    static bool _hitCheckLoop(dCc_c *c1, dCc_c *c2);
    static bool _hitCheckCircle(dCc_c *c1, dCc_c *c2);
    static bool _hitCheckBoxCircle(dCc_c *c1, dCc_c *c2);
 
    static int _lineCheckUD(mVec2_c p1, mVec2_c p2, float p3, float p4);
    static bool _hitCheckDaikeiUD_R(dCc_c *ccBox, dCc_c *ccTrp);
    static bool _hitCheckDaikeiUD(dCc_c *ccTrp, dCc_c *ccBox);
 
    static int _lineCheckLR(mVec2_c p1, mVec2_c p2, float p3, float p4);
    static bool _hitCheckDaikeiLR_R(dCc_c *ccBox, dCc_c *ccTrp);
    static bool _hitCheckDaikeiLR(dCc_c *ccTrp, dCc_c *ccBox);
 
private:
    dActor_c *mpOwner; 
    dActor_c *mFriendActor; 
 
    u32 unk2; 
 
    dCc_c *mpNext; 
    dCc_c *mpPrev; 
 
    u32 unk3; 
 
    CcData_s mCcData; 
 
public:
    float mTrpOffsets[4];
 
    float mCollOffsetX[8];
    float mCollOffsetY[8];
 
    mVec2_c mCollPos; 
 
    u16 mCollidedWith; 
    u16 mAttSent; 
    u16 mAttReceived; 
 
    u8 mShape; 
 
    u8 mNonCollideMask;
 
    u8 mLayer;
 
    u8 mFlag; 
 
private:
    bool mIsLinked; 
 
    typedef bool (*hitCheck)(dCc_c *, dCc_c *);
 
    static hitCheck _hitCheck[4][4];
 
    static dCc_c *mEntryN; 
    static dCc_c *mEntryB; 
};