GxUnitCharacterBase.h

Go to the documentation of this file.

//===========================================================================
//===========================================================================
#pragma once
 
GX_CHARACTER_NAMESPACE_BEGIN()
 
class GxFlock;
 
//===========================================================================
//===========================================================================
class GxUnitCharacterBase : public GxUnitMotion
{
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    // RTTI定義
    GX_RTTI_CLASS_NAME_ICON(GxUnitCharacterBase, GxUnitMotion, "キャラクタ基礎", GxRtti::ICON_TYPE::UNIT_PLAYER)
    // GxClassBaseReference継承クラス用禁止宣言
    GX_PROHIBIT_CLASS_BASE_REFERENCE(GxUnitCharacterBase)
 
    
    static constexpr u32 DERIVED_CLASS_MAX = GxMath::VALUE_256;
    static constexpr u32 ACTION_STATUS_ALL = 0xFFFFF000;
    static constexpr u32 ACTION_STATUS_SHIFT = 0x1000;
    static constexpr u32 ACTION_NUMBER_MAX = GxMath::VALUE_4;
 
    class GxAction : public GxClassBase
    {
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    public:
        // RTTI定義
        GX_RTTI_CLASS(GxAction, GxClassBase)
        static const f32 INVALID_TIME;
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
    private:
        GxAction(void) : _time(0.f){}
    public:
        GxAction(u32 number0, u32 number1 = 0, u32 number2 = 0, u32 number3 = 0);
        GX_FORCE_INLINE b32 operator == (const GxAction& action) const { return _number == action._number; }
 
        //-----------------------------------------------------------
        //-----------------------------------------------------------
 
        union
        {
            u32 _number;                
            struct
            {
#if GX_BITFIELD_LITTLEENDIAN
                u32 _number0 : 8;       
                u32 _number1 : 8;       
                u32 _number2 : 8;       
                u32 _number3 : 8;       
#else //GX_BITFIELD_LITTLEENDIAN
                u32 _number3 : 8;       
                u32 _number2 : 8;       
                u32 _number1 : 8;       
                u32 _number0 : 8;       
#endif // !GX_BITFIELD_LITTLEENDIAN
            };
        };
        f32 _time;                      
        b32 _initializeFlag;            
 
    };
 
    static constexpr s32 INVALID_PLAYER_NUMBER = -1;
    static constexpr u32 INVALID_SOUND_CHAR_ID = 0xFFFFFFFF;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
 
    GxUnitCharacterBase(void);
    void cleanup(void) override;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    b32 setup(void) override;
    void preAsyncUpdate(void) override;
 
public:
    void kill(void) override;
 
    GX_FORCE_INLINE virtual void backgroundHitCallback(void) {}
    GX_FORCE_INLINE virtual void objectHitCallback(void) {}
    virtual void attackHitCallback(GxAttackHit::GxObject* pObject);
    GX_FORCE_INLINE virtual void attackHitCallbackAttack(GxAttackHit::GxObject* /*pObject*/) {}
    GX_FORCE_INLINE virtual void attackHitCallbackDamage(GxAttackHit::GxObject* /*pObject*/) {}
    GX_FORCE_INLINE virtual void eventHitCallback(GxEventHit::GxObject* /*pObject*/) {};
 
    void setPad(b32 flag);
    void setPadNo(GxSysInput::DEVICE device, b32 changeForceFlag = true);
 
protected:
    virtual void updateInitialize(void);
    GX_FORCE_INLINE virtual void updateInitializeActionChange(void){}
    virtual void updateThink(void);
    virtual void updateThinkControl(void);
    GX_FORCE_INLINE virtual void updateThinkAI(void){};
    GX_FORCE_INLINE virtual void updateAction(void){};
 
#if GX_DEVELOP
    void developRender(void) override;
    static GxGuiBase* createGui(GxProperty& property, GxTypedObject* pOwner, const GxRtti& rtti, u32 index = 0);
    void iconRender(void) override;
    void addUnitOwnProperty(GxPropertyTable& propertyTable) override;
#endif // GX_DEVELOP
 
private:
    void updatePadValue(void);
    GxVector3 getAnalogStickWorldVector(f32 rateX, f32 rateY) const;
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
public:
    GX_FORCE_INLINE const GxAction& getAction(void) const { return _action; }
    void setAction(u32 action0, u32 action1 = 0, u32 action2 = 0, u32 action3 = 0);
    GX_FORCE_INLINE void setAction(const GxAction& action){ _action = action; }
    constexpr u32 getActionStatus(void) const { return _actionStatus; }
    constexpr void setActionStatus(u32 actionStatus){ _actionStatus = actionStatus; }
    GX_FORCE_INLINE b32 isActionStatus(u32 actionStatus) const { return _actionStatus == actionStatus; }
    GX_FORCE_INLINE b32 isActionStatusBit(u32 actionStatus) const { return (_actionStatus & actionStatus) ? true : false; }
 
    constexpr s32 getPlayerNumber(void) const { return _playerNumber; }
    constexpr void setPlayerNumber(s32 number){ _playerNumber = number; }
    constexpr GxPad* getPad(void) const { return _pPad; }
    b32 isPad(void) const { return _pPad ? true : false; }
    constexpr GxUnitCameraBase* getCamera(void) const { return _pCamera; }
    constexpr void setCamera(GxUnitCameraBase* pCamera){ _pCamera = pCamera; }
    GX_FORCE_INLINE GxVector3 getPadWorldVectorLeft(void) const { return _padWorldVectorLeft; }
    GX_FORCE_INLINE GxVector3 getPadWorldVectorRight(void) const { return _padWorldVectorRight; }
 
    GX_FORCE_INLINE const GxVector3& getMoveDirect(void) const { return _moveDirect; }
    GX_FORCE_INLINE void setMoveDirect(const GxVector3& direct){ _moveDirect = direct; }
    constexpr f32 getMoveSpeed(void) const { return _moveSpeed; }
    constexpr void setMoveSpeed(f32 speed){ _moveSpeed = speed; }
    constexpr f32 getRotateSpeed(void) const { return _rotateSpeed; }
    constexpr void setRotateSpeed(f32 speed){ _rotateSpeed = speed; }
    constexpr GxUnitCharacterBase* getMoveTarget(void) const { return _pMoveTarget; }
    constexpr void setMoveTarget(GxUnitCharacterBase* pUnit){ _pMoveTarget = pUnit; }
    GX_FORCE_INLINE f32 getMoveTargetDistance(void) const { return (_pMoveTarget->getLocalPosition() - getLocalPosition()).getLength(); }
    constexpr GxFlock* getFlock(void) const { return _pFlock; }
    constexpr void setFlock(GxFlock* pFlock){ _pFlock = pFlock; }
    void setLeader(void);
    GX_FORCE_INLINE GxVector3 getOldPosition(void) const { return _oldPosition; }
 
    const GxVector3 getDirectVectorX(void) const;
    const GxVector3 getDirectVectorZ(void) const;
    GX_FORCE_INLINE f32 getDistance(GxUnitCharacterBase* pUnit) const { return (pUnit->getLocalPosition() - getLocalPosition()).getLength(); }
    GX_FORCE_INLINE f32 getDistanceV(GxUnitCharacterBase* pUnit) const { return GxMath::getAbs(pUnit->getLocalPosition()._y - getLocalPosition()._y); }
    GX_FORCE_INLINE f32 getDistanceH(GxUnitCharacterBase* pUnit) const { return (GxVector2(pUnit->getLocalPosition()._x, pUnit->getLocalPosition()._z) - GxVector2(getLocalPosition()._x, getLocalPosition()._z)).getLength(); }
    GX_FORCE_INLINE f32 getAngleV(GxUnitCharacterBase* pUnit) const { return GxVector3::getAngle(pUnit->getLocalPosition() - getLocalPosition(), GxVector3(pUnit->getLocalPosition()._x, getLocalPosition()._y, pUnit->getLocalPosition()._z) - getLocalPosition()); }
    GX_FORCE_INLINE f32 getAngleH(GxUnitCharacterBase* pUnit) const { return GxVector3::getAngle(getDirectVectorZ(), GxVector3(pUnit->getLocalPosition()._x, getLocalPosition()._y, pUnit->getLocalPosition()._z) - getLocalPosition()); }
 
    constexpr f32 getLifeMax(void) const { return _lifeMax; }
    constexpr void setLifeMax(f32 lifeMax){ _lifeMax = lifeMax; }
    constexpr void addLifeMax(f32 add){ _lifeMax += add; }
    constexpr f32 getLife(void) const { return _life; }
    GX_FORCE_INLINE void setLife(f32 life){ _life = GxMath::getMin(life, _lifeMax); }
    GX_FORCE_INLINE void addLife(f32 add){ _life = GxMath::getMin(_life + add, _lifeMax); }
    constexpr f32 getLifeRate(void) const { return (_lifeMax == 0.0f) ? 0.0f : (_life / _lifeMax); }
 
    //-----------------------------------------------------------
    //-----------------------------------------------------------
protected:
    GxAction                    _action;                    
    u32                         _actionStatus;              
 
protected:
    GxVector3                   _padWorldVectorLeft;        
    GxVector3                   _padWorldVectorRight;       
    f32                         _padMarginRatio;            
private:
    s32                         _playerNumber;              
    GxPad*                      _pPad;                      
    GxUnitCameraBase*           _pCamera;                   
 
    GxVector3                   _moveDirect;                
    f32                         _moveSpeed;                 
    f32                         _rotateSpeed;               
    GxUnitCharacterBase*        _pMoveTarget;               
 
    GxFlock*                    _pFlock;                    
    GxVector3                   _oldPosition;               
 
    f32                         _lifeMax;                   
    f32                         _life;                      
 
protected:
    GxSysSoundBase::GxObjMotionData _objMotionSound;        
 
#if GX_DEVELOP
    GxVector3 _developRenderPosition;                       
#endif // GX_DEVELOP
};
 
GX_CHARACTER_NAMESPACE_END()