human.c

Go to the documentation of this file.

 
enum HumanInputControllerOverrideType
{
    DISABLED,
    ENABLED,        
    ONE_FRAME,      
};
 
// *************************************************************************************
// ! HumanInputController - what we know about the input - human.GetInputController()
// *************************************************************************************
class HumanInputController
{
    //--------------------------------------------------------------
 
    proto native void           SetDisabled(bool pState);
    
    proto void                  GetMovement(out float pSpeed, out vector pLocalDirection);
 
    proto native float          GetHeadingAngle();
 
    proto native vector         GetAimChange();
 
    proto native vector         GetAimDelta(float dt);
 
    proto native vector         GetTracking();
 
    proto native bool           CameraViewChanged();
 
    proto native bool           CameraIsFreeLook();
    
    proto native void           ResetFreeLookToggle();
 
    proto native bool           CameraIsTracking();
 
    proto native bool           Camera3rdIsRightShoulder();
 
    //--------------------------------------------------------------
 
    proto native bool           IsStanceChange();
 
    proto native bool           IsJumpClimb();
 
 
    //--------------------------------------------------------------
 
    proto native bool           IsMeleeEvade();
 
    proto native bool           IsMeleeFastAttackModifier();
 
    proto native int            IsMeleeLREvade();
 
    proto native bool           IsMeleeWeaponAttack();
 
    //--------------------------------------------------------------
 
    proto native bool           WeaponWasRaiseClick();
 
    proto native bool           IsWeaponRaised();
 
    proto native bool           WeaponADS();
 
    proto native void           ResetADS();
    
    proto native bool           IsThrowingModeChange();
 
    proto native void           ResetThrowingMode();
    
    proto native bool           IsWalkToggled();
 
    //--------------------------------------------------------------
    
    proto native bool           IsUseButton();
 
    proto native bool           IsUseButtonDown();
    
        proto native bool           IsUseItemButton();
        proto native bool           IsUseItemButtonDown();
        
        proto native bool           IsAttackButton();
        proto native bool           IsAttackButtonDown();
 
    proto native bool           IsSingleUse();
 
    proto native bool           IsContinuousUse();
 
    proto native bool           IsContinuousUseStart();
 
    proto native bool           IsContinuousUseEnd();
 
    proto native bool           IsImmediateAction(); //TODO: revise, may be obsolete
 
    //--------------------------------------------------------------
    
    proto native bool           IsReloadOrMechanismSingleUse();
 
    proto native bool           IsReloadOrMechanismContinuousUse();
 
    proto native bool           IsReloadOrMechanismContinuousUseStart();
 
    proto native bool           IsReloadOrMechanismContinuousUseEnd();
 
    proto native bool           IsZoom();
 
    proto native bool           IsZoomToggle();
 
    proto native void           ResetZoomToggle();
 
    proto native bool           IsSightChange();
 
    proto native bool           IsZoomIn();
 
    proto native bool           IsZoomOut();
 
    proto native bool           IsFireModeChange();
 
    proto native bool           IsZeroingUp();
 
    proto native bool           IsZeroingDown();
 
    proto native bool           IsHoldBreath();
 
    proto native void           ResetHoldBreath();
 
    //--------------------------------------------------------------
 
    proto native int            IsGestureSlot();
 
    proto native bool           IsOtherController();
 
    //--------------------------------------------------------------
 
    proto native int            IsQuickBarSlot();
 
    proto native bool           IsQuickBarSingleUse();
 
    proto native bool           IsQuickBarContinuousUse();
 
    proto native bool           IsQuickBarContinuousUseStart();
 
    proto native bool           IsQuickBarContinuousUseEnd();
 
 
 
    //--------------------------------------------------------------
    // LIMITS 
 
    proto native void           LimitsDisableSprint(bool pDisable);
 
    proto native bool           LimitsIsSprintDisabled();
    
 
    //--------------------------------------------------------------
    // overrides
 
    proto native void           OverrideMovementSpeed(HumanInputControllerOverrideType overrideType, float value);
 
    proto native void           OverrideMovementAngle(HumanInputControllerOverrideType overrideType, float value);
    
    proto native void           OverrideAimChangeX(HumanInputControllerOverrideType overrideType, float value);
 
    proto native void           OverrideAimChangeY(HumanInputControllerOverrideType overrideType, float value);
 
    proto native void           OverrideMeleeEvade(HumanInputControllerOverrideType overrideType, bool value);
 
    proto native void           OverrideRaise(HumanInputControllerOverrideType overrideType, bool value);
 
    proto native void           Override3rdIsRightShoulder(HumanInputControllerOverrideType overrideType, bool value);
 
    proto native void           OverrideFreeLook(HumanInputControllerOverrideType overrideType, bool value);
 
 
    //--------------------------------------------------------------
 
    private void HumanInputController()
    {
    }
 
    private void ~HumanInputController()
    {
    }   
}
 
 
// *************************************************************************************
// ! HumanInputController - what we know about the input - human.GetInputController()
// *************************************************************************************
 
typedef     int     TAnimGraphCommand;
typedef     int     TAnimGraphVariable;
typedef     int     TAnimGraphTag;
typedef     int     TAnimGraphEvent;
 
class HumanAnimInterface
{
    private void HumanAnimInterface();
    private void ~HumanAnimInterface();
    
    //-----------------------------------------------------
    // Binds, returns -1 when error, otherwise if ok
 
    proto native TAnimGraphCommand      BindCommand(string pCommandName);
 
    proto native TAnimGraphVariable     BindVariableFloat(string pVariable);
    proto native TAnimGraphVariable     BindVariableInt(string pVariable);
    proto native TAnimGraphVariable     BindVariableBool(string pVariable);
 
    proto native TAnimGraphTag          BindTag(string pTagName);
 
    proto native TAnimGraphEvent        BindEvent(string pEventName);
}
 
 
// *************************************************************************************
// ! HumanCommandActionCallback - called as action callback 
// *************************************************************************************
class HumanCommandActionCallback
{
    private void HumanCommandActionCallback();
    private void ~HumanCommandActionCallback();
    
    proto native Human      GetHuman();
    
    proto native    void    Cancel();
 
    proto native    void    InternalCommand(int pInternalCommandId);    
    
    proto native    void    SetAligning(vector pPositionWS, vector pDirectionWS);
 
    proto native    void    ResetAligning();
 
    proto native    void    EnableCancelCondition(bool pEnable);
 
    proto native    bool    DefaultCancelCondition();
 
    proto native void       RegisterAnimationEvent(string pAnimationEventStr, int pId);
 
    proto native void       EnableStateChangeCallback();
 
    //  bool                CancelCondition()   { return false; }
 
    static const int    STATE_NONE          = 0;
 
    static const int    STATE_LOOP_IN       = 1;
    static const int    STATE_LOOP_LOOP     = 2;
    static const int    STATE_LOOP_END      = 3;
    static const int    STATE_LOOP_END2     = 4;
    static const int    STATE_LOOP_LOOP2    = 5;
    static const int    STATE_LOOP_ACTION   = 6;
 
    static const int    STATE_NORMAL        = 7;
 
    proto native int    GetState();
 
 
    //----------------------------------
    // debug helper
 
    static string   GetStateString(int pState)
    {
        switch (pState)
        {
        case STATE_NONE:            return "NONE";
 
        case STATE_LOOP_IN:         return "LOOP_IN";
        case STATE_LOOP_LOOP:       return "LOOP_LOOP";
        case STATE_LOOP_END:        return "LOOP_END";
        case STATE_LOOP_END2:       return "LOOP_END2";
        case STATE_LOOP_LOOP2:      return "LOOP_LOOP2";
        case STATE_LOOP_ACTION:     return "LOOP_ACTION";
 
        case STATE_NORMAL:          return "ONE TIME";
        }
 
        return "Undef";
    }
 
 
    string  GetStateString()
    {
        return GetStateString(GetState());
    }
 
 
 
    //----------------------------------
    // callbacks
 
    void    OnAnimationEvent(int pEventID)  {};
 
    void    OnFinish(bool pCanceled)    {};     
 
    void    OnStateChange(int pOldState, int pCurrentState)         {};
    
    
    // helps identify type of callback
    bool IsUserActionCallback()
    {
        return false;
    }
    
    bool IsGestureCallback()
    {
        return false;
    }
    
    bool IsSymptomCallback()
    {
        return false;
    }
}
 
 
// *************************************************************************************
// ! HumanCommandMove
// *************************************************************************************
class HumanCommandMove
{
    private void HumanCommandMove() {}
    private void ~HumanCommandMove() {}
    
    proto native float      GetCurrentMovementAngle();
        
    proto bool              GetCurrentInputAngle(out float pAngle);
 
    proto native float      GetCurrentMovementSpeed();
    
    proto native bool       IsChangingStance();
    
    proto native bool       IsOnBack();
    
    proto native bool       IsInRoll();
    
    proto native bool       IsLeavingUncon();
 
    proto native bool       IsStandingFromBack();
 
    proto native void       StartMeleeEvade();
 
    proto native void       StartMeleeEvadeA(float pDirAngle);
 
    proto native bool       IsMeleeEvade();
 
    proto native void       SetMeleeBlock(bool pBlock);
 
    proto native void       ForceStance(int pStanceIdx);
 
 
    proto native void       ForceStanceUp(int pStanceIdx);
 
 
    proto native void       SetRunSprintFilterModifier(float value);
 
    proto native void       SetDirectionFilterModifier(float value);
 
    proto native void       SetDirectionSprintFilterModifier(float value);
 
    proto native void       SetTurnSpanModifier(float value);
 
    proto native void       SetTurnSpanSprintModifier(float value);
    
    proto native void       SetCurrentWaterLevel(float value);
}
 
 
 
// *************************************************************************************
// ! HumanCommandMelee - actual command melee running on 
// *************************************************************************************
class HumanCommandMelee
{
    private void HumanCommandMelee() {}
    private void ~HumanCommandMelee() {}
    
    proto native void       ContinueCombo();
 
    proto native bool       IsInComboRange();
 
    proto native bool       WasHit();
 
    proto native void       Cancel();
    
    proto native bool       IsOnBack();
}
 
 
// *************************************************************************************
// ! HumanCommandMelee2 - actual command melee running on - Heavy/Light version
// *************************************************************************************
class HumanCommandMelee2
{
    private void HumanCommandMelee2() {}
    private void ~HumanCommandMelee2() {}
    
    static const int HIT_TYPE_LIGHT = 0;
    static const int HIT_TYPE_HEAVY = 1;
    static const int HIT_TYPE_FINISHER = 2; //liver stab
    static const int HIT_TYPE_FINISHER_NECK = 3;
    
    proto native void       ContinueCombo(bool pHeavyHit, float pComboValue, EntityAI target = null, vector hitPos = vector.Zero);
 
    proto native bool       IsInComboRange();
 
    proto native bool       WasHit();
 
    proto native void       Cancel();
 
    proto native bool       IsOnBack();
    
    proto native int        GetComboCount();
    
    proto native int        GetCurrentHitType();
    
    proto native bool       IsFinisher();
}
 
 
// *************************************************************************************
// ! HumanCommandFall - actually falling 
// *************************************************************************************
class HumanCommandFall
{
    private void HumanCommandFall() {}
    private void ~HumanCommandFall() {}
    
    static const int LANDTYPE_NONE = 0;
    static const int LANDTYPE_LIGHT = 1;
    static const int LANDTYPE_MEDIUM = 2;
    static const int LANDTYPE_HEAVY = 3;
 
    proto native bool   PhysicsLanded();
    
    proto native void   Land(int pLandType);
    
    proto native bool   IsLanding();
}
 
// *************************************************************************************
// ! HumanCommandDeathCallback - called as action callback 
// *************************************************************************************
class HumanCommandDeathCallback
{
    //----------------------------------
    // callbacks
 
    void    OnSimulationEnd()   {};     
 
    bool    ShouldSimulationBeDisabled() { return true; };
}
 
// *************************************************************************************
// ! HumanCommandDeath - actually dying
// *************************************************************************************
class HumanCommandDeath
{   
    private void HumanCommandDeath() {}
    private void ~HumanCommandDeath() {}
}
 
 
// *************************************************************************************
// ! HumanCommandUnconscious - actually not dying
// *************************************************************************************
class HumanCommandUnconscious
{   
    private void HumanCommandUnconscious() {}
    private void ~HumanCommandUnconscious() {}
    
    proto native void   WakeUp(int targetStance = -1);
    proto native bool   IsWakingUp();
    
    proto native bool   IsOnLand();
    proto native bool   IsInWater();
}
 
 
// *************************************************************************************
// ! HumanCommandDamage - additional damage 
// *************************************************************************************
class HumanCommandDamage
{   
    private void HumanCommandDamage() {}
    private void ~HumanCommandDamage() {}
}
 
// *************************************************************************************
// ! HumanCommandLadder ladder
// *************************************************************************************
class HumanCommandLadder
{   
    private void HumanCommandLadder() {}
    private void ~HumanCommandLadder() {}
    
    proto native bool               CanExit();
 
    proto native void               Exit();
 
    proto native static bool        DebugDrawLadder(Building pBuilding, int pLadderIndex);
    
    proto native static int         DebugGetLadderIndex(string pComponentName); 
 
    proto native vector             GetLogoutPosition();
}
 
 
 
// *************************************************************************************
// ! HumanCommandLadder ladder
// *************************************************************************************
class HumanCommandSwim
{
    private void HumanCommandSwim() {}
    private void ~HumanCommandSwim() {}
    
    proto native void               StopSwimming();
 
    proto native static vector      WaterLevelCheck(Human pHuman, vector pPosition);
}
 
 
 
// *************************************************************************************
// ! HumanCommandVehicle vehicle
// *************************************************************************************
class HumanCommandVehicle
{
    private void HumanCommandVehicle() {}
    private void ~HumanCommandVehicle() {}
    
    proto native Transport          GetTransport();
    proto native int                GetVehicleClass();
    proto native int                GetVehicleSeat();
    proto native void               SetVehicleType(int pVehicleType);
    proto native int                GetVehicleType();
    
    proto native void               GetOutVehicle();
    proto native void               KnockedOutVehicle();
    proto native bool               ShouldBeKnockedOut();
    proto native void               JumpOutVehicle();
    proto native void               SwitchSeat(int pTransportPositionIndex, int pVehicleSeat);
    proto native bool               IsGettingIn();
    proto native bool               IsGettingOut();
    proto native bool               IsSwitchSeat();
    proto native bool               WasGearChange();
    proto native void               SetClutchState(bool pState);
    proto native void               KeepInVehicleSpaceAfterLeave(bool pState);
 
    bool IsObjectIgnoredOnGettingOut(IEntity entity)
    {
        Object object;
        if (!Class.CastTo(object, entity))
        {
            return true;
        }
 
        Transport transport = GetTransport();
        if (!transport)
        {
            return true;
        }
 
        if (object == transport || object.GetParent() == transport)
        {
            return true;
        }
 
        return transport.IsIgnoredObject(object);
    }
}
 
// *************************************************************************************
// ! HumanCommandClimb
// *************************************************************************************
 
class SHumanCommandClimbResult
{
    bool        m_bIsClimb; 
    bool        m_bIsClimbOver;
    bool        m_bFinishWithFall;
    bool        m_bHasParent;
 
    float       m_fClimbHeight;
    
    vector      m_ClimbGrabPoint;       
    vector      m_ClimbGrabPointNormal; 
    vector      m_ClimbStandPoint;      
    vector      m_ClimbOverStandPoint;  
    
    IEntity     m_GrabPointParent;      
    IEntity     m_ClimbStandPointParent;
    IEntity     m_ClimbOverStandPointParent;
};
 
 
enum ClimbStates
{
    STATE_MOVE,
    STATE_TAKEOFF,
    STATE_ONTOP,
    STATE_FALLING,
    STATE_FINISH
};
 
class HumanCommandClimb
{
    private void HumanCommandClimb() {}
    private void ~HumanCommandClimb() {}
    
    proto native int                GetState();
    
    proto native vector             GetGrabPointWS();
    
    proto native vector             GetClimbOverStandPointWS();
    
    proto native static bool        DoClimbTest(Human pHuman, SHumanCommandClimbResult pResult, int pDebugDrawLevel);
 
    proto native static bool        DebugDrawClimb(Human pHuman, int pLevel);
}
 
 
 
 
// *************************************************************************************
// ! HumanCommandFullBodyDamage - full body damages
// *************************************************************************************
class HumanCommandFullBodyDamage
{   
    private void HumanCommandFullBodyDamage() {}
    private void ~HumanCommandFullBodyDamage() {}
}
 
 
enum WeaponActions
{
    INTERRUPT           = 15,
    NONE                = -1,
    RELOAD              = 0,
    MECHANISM           = 1,
    CHAMBERING          = 2,
    CHAMBERING_LOADER   = 3,
    UNJAMMING           = 4,
    FIRE                = 5,
    HIDE                = 6,
    SHOW                = 7,
    RELOAD_CLIP         = 8,
};
enum WeaponActionReloadTypes
{
    RELOADRIFLE_MAGAZINE_BULLET             = 0,        // CMD_Reload_Magazine
    RELOADRIFLE_NOMAGAZINE_BULLET           = 1,
    RELOADRIFLE_MAGAZINE_NOBULLET           = 2,
    RELOADRIFLE_NOMAGAZINE_NOBULLET         = 3,
    RELOADRIFLE_MAGAZINE_NOBULLET_OPEN      = 4,
    RELOADRIFLE_NOMAGAZINE_NOBULLET_OPEN    = 5,
 
    // reload action types - pistols
    RELOADPISTOL_NOMAGAZINE_NOBULLET_CLOSED_UNCOCKED    = 8, // CMD_Reload_Magazine 
    RELOADPISTOL_MAGAZINE_NOBULLET_CLOSED_UNCOCKED      = 9,
    RELOADPISTOL_MAGAZINE_BULLET_CLOSED                 = 10,           
    RELOADPISTOL_NOMAGAZINE_BULLET_CLOSED               = 11,
    RELOADPISTOL_MAGAZINE_NOBULLET_CLOSED_COCKED        = 12,
    RELOADPISTOL_NOMAGAZINE_NOBULLET_CLOSED_COCKED      = 13,
    RELOADPISTOL_NOMAGAZINE_NOBULLET_OPENED             = 14,
    RELOADPISTOL_MAGAZINE_NOBULLET_OPENED               = 15,
 
    RELOAD_MAGAZINE_DETACH  = 16,
    RELOADRIFLE_MAGAZINE_DETACH = 17,                    // CMD_Reload_Magazine
 
    RELOADSRIFLE_MAGAZINE_BULLET        = 20,           // CMD_Reload_Magazine
    RELOADSRIFLE_NOMAGAZINE_BULLET      = 21,
    RELOADSRIFLE_MAGAZINE_NOBULLET      = 22,
    RELOADSRIFLE_NOMAGAZINE_NOBULLET    = 23,
};
 
enum WeaponActionReloadClipTypes
{
    RELOADRIFLE_CLIP_NOBULLET           = 0,
    RELOADRIFLE_CLIP_BULLET             = 1,
}
 
enum WeaponActionMechanismTypes
{
    MECHANISM_OPENED    = 0,        // CMD_Reload_BoltAction
    MECHANISM_CLOSED    = 1,        
    MECHANISM_SPECIAL   = 2,        // crossbow, magnum ... special mechanism action apropriate for custom weapons
    MECHANISM_CLOSED_UNCOCKED   = 3,    
};
 
enum WeaponActionChamberingTypes
{
    CHAMBERING_END = -1,
    CHAMBERING_ONEBULLET_OPENED                 = 0,        // CMD_Reload_Chambering
    CHAMBERING_ONEBULLET_CLOSED                 = 1,        //
    CHAMBERING_ONEBULLET_CLOSED_UNCOCKED        = 2,
    CHAMBERING_ONEBULLET_UNIQUE_OPENED          = 3,        //
    CHAMBERING_ONEBULLET_UNIQUE_CLOSED          = 4,        //
    CHAMBERING_TWOBULLETS_START                 = 6,        //  plays one bullet, then second, then ends, when CHAMBERING_TWOBULLETS_END arise, it's canceled
    CHAMBERING_TWOBULLETS_END                   = 7,        //  - one bullet reload with closed mechanism       
    CHAMBERING_STARTLOOPABLE_CLOSED             = 10,       // start loop chambering
    CHAMBERING_ENDLOOPABLE                      = 11,       // end loop chambering
    CHAMBERING_STARTLOOPABLE_CLOSED_KEEP        = 12,       // start loop chambering and keep last bullet
    CHAMBERING_STARTLOOPABLE_OPENED             = 13,       // 
    
    CHAMBERING_STARTLOOPABLE_SHOTGUN_UNCOCKED   = 15,
    CHAMBERING_STARTLOOPABLE_SHOTGUN_COCKED     = 16, 
    
    CHAMBERING_DOUBLE_1             = 17,
    CHAMBERING_DOUBLE_2             = 18,
    CHAMBERING_DOUBLE_3             = 19,
    CHAMBERING_DOUBLE_4             = 20,
    
 
    CHAMBERING_CROSSBOW_OPENED          = 21,       // chambering crossbow
    CHAMBERING_CROSSBOW_CLOSED          = 22,       // chambering crossbow
    CHAMBERING_CROSSBOW_FULL            = 23,       // chambering crossbow
};
 
enum WeaponActionChamberingLoaderTypes
{
    CHAMBERINGLOADER_OPENED     = 0,        // CMD_Reload_ChamberingFast - one bullet reload with open mechanism
    CHAMBERINGLOADER_CLOSED     = 1,        //  - one bullet reload with closed mechanism
};
 
enum WeaponActionUnjammingTypes
{
    UNJAMMING_START                     = 1,        // CMD_Weapon_Jam - 0
    UNJAMMING_END                       = 0,        // 1
    UNJAMMING_INTERRUPT                 = -1,
};
 
enum WeaponActionFireTypes
{
    FIRE_NORMAL                         = 0,
    FIRE_LAST                           = 1,
    FIRE_COCKED                         = 2,
    FIRE_UNCOCKED                       = 3,
    FIRE_DRY                            = 4,
    FIRE_JAM                            = 5
};
 
enum WeaponHideShowTypes
{ 
    HIDESHOW_SLOT_2HDLEFTBACK = 0,
    HIDESHOW_SLOT_RFLLEFTBACK = 1,
    HIDESHOW_SLOT_1HDLEFTBACK = 2,
    HIDESHOW_SLOT_2HDRIGHTBACK = 3,
    HIDESHOW_SLOT_RFLRIGHTBACK = 4,
    HIDESHOW_SLOT_1HDRIGHTBACK = 5,
    HIDESHOW_SLOT_PISTOLBELT = 6,
    HIDESHOW_SLOT_PISTOLCHEST = 7,
    HIDESHOW_SLOT_KNIFEBACK = 8,
    HIDESHOW_SLOT_INVENTORY = 9,
};
 
string WeaponActionTypeToString (int A, int AT)
{
    switch (A)
    {
        case WeaponActions.INTERRUPT: return "Weapon interrupt";
        case WeaponActions.NONE: return "---";
        case WeaponActions.RELOAD: return typename.EnumToString(WeaponActionReloadTypes, AT);
        case WeaponActions.MECHANISM: return typename.EnumToString(WeaponActionMechanismTypes, AT);
        case WeaponActions.CHAMBERING: return typename.EnumToString(WeaponActionChamberingTypes, AT);
        case WeaponActions.CHAMBERING_LOADER: return typename.EnumToString(WeaponActionChamberingLoaderTypes, AT);
        case WeaponActions.UNJAMMING: return typename.EnumToString(WeaponActionUnjammingTypes, AT);
        case WeaponActions.FIRE: return typename.EnumToString(WeaponActionFireTypes, AT);
        case WeaponActions.HIDE: return typename.EnumToString(WeaponHideShowTypes, AT);
        case WeaponActions.SHOW: return typename.EnumToString(WeaponHideShowTypes, AT);
    }
    return "---";
}
 
enum WeaponEvents
{
    ATTACHMENT_HIDE,
    ATTACHMENT_SHOW,
    BULLET_EJECT,
    BULLET_HIDE,
    BULLET_HIDE2,
    BULLET_IN_CHAMBER,
    BULLET_IN_MAGAZINE,
    BULLET_SHOW,
    BULLET_SHOW2,
    CANUNJAM_END,
    CANUNJAM_START,
    COCKED,
    MAGAZINE_ATTACHED,
    MAGAZINE_DETACHED,
    MAGAZINE_HIDE,
    MAGAZINE_SHOW,
    SLIDER_OPEN,
    UNJAMMED,
    HAMMER_UNCOCKED,
    HAMMER_COCKED
    CHANGE_HIDE,
    CHANGE_SHOW,
    CYLINDER_ROTATE,
};
 
 
// *************************************************************************************
// ! HumanCommandWeapons - weapon handling
// *************************************************************************************
class HumanCommandWeapons
{
    private void HumanCommandWeapons() {}
    private void ~HumanCommandWeapons() {}
    
    proto native    bool        IsActionFinished();
    
    proto native    int         GetRunningAction();
 
    proto native    int         GetRunningActionType();
 
    proto native    void        SetActionProgressParams(float pStart, float pEnd);
 
    proto native    bool        StartAction(WeaponActions pAction, int pActionType);
 
    proto native    void        RegisterEvent(string pName, int pId);
 
    proto native    int         IsEvent();
    
    proto native    bool        IsInWeaponReloadBulletSwitchState();
 
    proto native    void        SetADS(bool pState);
 
    proto native    void        LiftWeapon(bool pState);
 
    void    RegisterDefaultEvents()
    {
        RegisterEvent("Weapon_AttachmentHide", WeaponEvents.ATTACHMENT_HIDE);
        RegisterEvent("Weapon_AttachmentShow", WeaponEvents.ATTACHMENT_SHOW);
        RegisterEvent("Weapon_BulletEject", WeaponEvents.BULLET_EJECT);
        RegisterEvent("Weapon_BulletHide", WeaponEvents.BULLET_HIDE);
        RegisterEvent("Weapon_BulletHide2", WeaponEvents.BULLET_HIDE2);
        RegisterEvent("Weapon_BulletInChamber", WeaponEvents.BULLET_IN_CHAMBER);
        RegisterEvent("Weapon_BulletInMagazine", WeaponEvents.BULLET_IN_MAGAZINE);
        RegisterEvent("Weapon_BulletShow", WeaponEvents.BULLET_SHOW);
        RegisterEvent("Weapon_BulletShow2", WeaponEvents.BULLET_SHOW2);
        RegisterEvent("Weapon_CanUnjam_End", WeaponEvents.CANUNJAM_END);
        RegisterEvent("Weapon_CanUnjam_Start", WeaponEvents.CANUNJAM_START);
        RegisterEvent("Weapon_Cocked", WeaponEvents.COCKED);
        RegisterEvent("Weapon_MagazineAttached", WeaponEvents.MAGAZINE_ATTACHED);
        RegisterEvent("Weapon_MagazineDetached", WeaponEvents.MAGAZINE_DETACHED);
        RegisterEvent("Weapon_MagazineHide", WeaponEvents.MAGAZINE_HIDE);
        RegisterEvent("Weapon_MagazineShow", WeaponEvents.MAGAZINE_SHOW);
        RegisterEvent("Weapon_SliderOpen", WeaponEvents.SLIDER_OPEN);
        RegisterEvent("Weapon_Unjammed", WeaponEvents.UNJAMMED);
        RegisterEvent("Weapon_Hammer_Uncocked", WeaponEvents.HAMMER_UNCOCKED);
        RegisterEvent("Weapon_Hammer_Cocked", WeaponEvents.HAMMER_COCKED);
        RegisterEvent("Weapon_Change_Hide", WeaponEvents.CHANGE_HIDE);
        RegisterEvent("Weapon_Change_Show", WeaponEvents.CHANGE_SHOW);
        RegisterEvent("Weapon_CylinderRotate", WeaponEvents.CYLINDER_ROTATE);
    }
 
    //----------------------------------------------------
    // weapon init states
 
 
    proto native    void        SetInitState(int pFrameIndex);
 
    proto native static void    StaticSetInitState(Human pHuman, int pFrameIdx);
 
 
    //----------------------------------------------------
    // 
 
    proto native float          GetBaseAimingAngleUD();
 
    proto native float          GetBaseAimingAngleLR();
 
 
    //----------------------------------------------------
    // throwing
    proto native void           SetThrowingMode(bool pState);
    
    proto native bool           IsThrowingMode();
    
    proto native void           ThrowItem(int throwType);
    
    proto native bool           WasItemLeaveHandsEvent();
    
    //----------------------------------------------------
    // debug copy 
 
    proto native    int         DebugIsEvent();
 
    proto native    void        DebugResetEvents();
}
 
 
// *************************************************************************************
// ! HumanCommandAdditives - additional damage 
// *************************************************************************************
class HumanCommandAdditives
{
    private void HumanCommandAdditives() {}
    private void ~HumanCommandAdditives() {}
 
    proto native void   SetInjured(float pValue, bool pInterpolate);
 
    proto native void   SetExhaustion(float pValue, bool pInterpolate);
 
    proto native void   SetTalking(bool pValue);
 
    proto native void   StartModifier(int pType);
 
    proto native void   CancelModifier();
 
    proto native bool   IsModifierActive();
}
 
 
// *************************************************************************************
// ! HumanMovementState - movement state, command, stance, movement, human.GetMovementState(movementState)
// *************************************************************************************
class HumanMovementState
{
    int         m_CommandTypeId;    
    int         m_iStanceIdx;       
    int         m_iMovement;        
    float       m_fLeaning;         
    
    int         m_LocalMovement = -1;
    
    bool        IsRaised()
    {
        return m_iStanceIdx >= DayZPlayerConstants.STANCEIDX_RAISEDERECT;
    }
    
    bool        IsRaisedInProne()
    {
        return m_iStanceIdx == DayZPlayerConstants.STANCEIDX_RAISEDPRONE;
    }
    
    bool        IsInProne()
    {
        return m_iStanceIdx == DayZPlayerConstants.STANCEIDX_PRONE;
    }
 
    bool        IsInRaisedProne()
    {
        return m_iStanceIdx == DayZPlayerConstants.STANCEIDX_RAISEDPRONE;
    }   
        
    bool        IsLeaning()
    {
        return m_fLeaning != 0;
    }
}
 
 
class HumanCommandScript
{
    // HumanCommandScript(Human pHuman);
 
    void    OnActivate()    { };
 
    void    OnDeactivate()  { };
 
 
    //---------------------------------------------------------------
    // usable everywhere
 
    proto native void   SetFlagFinished(bool pFinished);
 
 
    //---------------------------------------------------------------
    // PreAnim Update 
 
    void    PreAnimUpdate(float pDt);
 
    proto native    void    PreAnim_CallCommand(int pCommand, int pParamInt, float pParamFloat);
    proto native    void    PreAnim_SetFloat(int pVar, float pFlt);
    proto native    void    PreAnim_SetInt(int pVar, int pInt);
    proto native    void    PreAnim_SetBool(int pVar, bool pBool);
 
    proto native    void    PreAnim_SetFilteredHeading(float pYawAngle, float pFilterDt, float pMaxYawSpeed);
 
    //---------------------------------------------------------------
    // PrePhys Update 
 
    void    PrePhysUpdate(float pDt);
 
    proto native    bool    PrePhys_IsEvent(int pEvent);
    proto native    bool    PrePhys_IsTag(int pTag);
    proto native    bool    PrePhys_GetTranslation(out vector pOutTransl);      // vec3 in local space !
    proto native    bool    PrePhys_GetRotation(out float pOutRot[4]);          // quaternion in local space !
    proto native    void    PrePhys_SetTranslation(vector pInTransl);           // vec3 in local space !
    proto native    void    PrePhys_SetRotation(float pInRot[4]);               // quaternion in local space !
 
    //---------------------------------------------------------------
    // PostPhys Update 
 
    bool    PostPhysUpdate(float pDt);
 
    proto native    void    PostPhys_GetPosition(out vector pOutTransl);        
    proto native    void    PostPhys_GetRotation(out float pOutRot[4]);         
    proto native    void    PostPhys_SetPosition(vector pInTransl);             
    proto native    void    PostPhys_SetRotation(float pInRot[4]);              
    proto native    void    PostPhys_LockRotation();                            
}
 
enum HumanMoveCommandID
{
    None = 0,
    CommandMove = 1,
    CommandMelee = 2,
    CommandMelee2 = 4,
    CommandFall = 8,
    CommandClimb = 16,
    CommandDeath = 32,
    CommandUnconscious = 64,
    CommandDamageFullbody = 128,
    CommandDamageAdditive = 256,
    CommandLadder = 512,
    CommandSwim = 1024,
    CommandVehicle = 2048,
    CommandActionFullbody = 4096,
    CommandActionAdditive = 8192
}
 
// *************************************************************************************
// ! Human - human script interface 
// *************************************************************************************
class Human extends Man
{
 
    proto native    void        GetTransformWS(out vector pTm[4]);
    
    proto native    bool        CheckFreeSpace(vector localDir, float distance, bool useHeading, vector posOffset = vector.Zero, float xzScale = 1.0);
 
    proto           float       CollisionMoveTest(vector dir, vector offset, float xzScale, IEntity ignoreEntity, out IEntity hitEntity, out vector hitPosition, out vector hitNormal);
 
    //---------------------------------------------------------
    // link/unlink to/from local space
    proto native    void        LinkToLocalSpaceOf(notnull IEntity child, vector pLocalSpaceMatrix[4]);
    proto native    void        UnlinkFromLocalSpace();
 
    //---------------------------------------------------------
    // bone transforms 
 
    proto native    int         GetBoneIndexByName(string pBoneName);
 
    
    proto native    HumanAnimInterface  GetAnimInterface();
 
    //---------------------------------------------------------
    // physic props
        
    proto native    bool        PhysicsIsFalling(bool pValidate);
 
    proto native    void        PhysicsGetVelocity(out vector pVelocity);
 
    proto native    void        PhysicsEnableGravity(bool pEnable);
 
    proto native    bool        PhysicsIsSolid();
    proto native    void        PhysicsSetSolid(bool pSolid);
 
    proto native    void        PhysicsSetRagdoll(bool pEnable);
 
    //---------------------------------------------------------
    // controller 
            
    proto native    HumanInputController    GetInputController();
 
    //---------------------------------------------------------
    // item accessor
 
    proto native    HumanItemAccessor       GetItemAccessor();
 
 
    //---------------------------------------------------------
    // commands 
 
    proto native    void    GetMovementState(HumanMovementState pState);
 
    proto native    int     GetCurrentCommandID();
 
 
 
    proto native    HumanCommandMove            StartCommand_Move();
 
    proto native    HumanCommandMove            GetCommand_Move();
 
 
    proto native    HumanCommandMelee           StartCommand_Melee(EntityAI pTarget);
 
    proto native    HumanCommandMelee           GetCommand_Melee();
 
    proto native    HumanCommandMelee2          StartCommand_Melee2(EntityAI pTarget, int pHitType, float pComboValue, vector hitPos = vector.Zero);
    
    proto native    HumanCommandMelee2          GetCommand_Melee2();
 
 
 
    proto native    HumanCommandFall            StartCommand_Fall(float pYVelocity);
 
    proto native    HumanCommandFall            GetCommand_Fall();
 
 
 
    proto native    HumanCommandLadder          StartCommand_Ladder(Building pBuilding, int pLadderIndex);
 
    proto native    HumanCommandLadder          GetCommand_Ladder();
 
 
 
    proto native    HumanCommandSwim            StartCommand_Swim();
 
    proto native    HumanCommandSwim            GetCommand_Swim();
 
 
 
    proto native    HumanCommandVehicle         StartCommand_Vehicle(Transport pTransport, int pTransportPositionIndex, int pVehicleSeat, bool fromUnconscious = false);
 
    proto native    HumanCommandVehicle         GetCommand_Vehicle();
 
 
 
    proto native    HumanCommandClimb           StartCommand_Climb(SHumanCommandClimbResult pClimbResult, int pType);
 
    proto native    HumanCommandClimb           GetCommand_Climb();
 
 
    proto native    HumanCommandDeathCallback   StartCommand_Death(int pType, float pDirection, typename pCallbackClass, bool pKeepInLocalSpaceAfterLeave = false);
 
    proto native    HumanCommandDeathCallback   GetCommand_Death();
 
 
    proto native    HumanCommandUnconscious     StartCommand_Unconscious(float pType);
 
    proto native    HumanCommandUnconscious     GetCommand_Unconscious();
 
 
 
    // -> of type 0,...
    // -> from direction (lback -180,left -90,0,righ 90,rightback 180)
    proto native    HumanCommandFullBodyDamage  StartCommand_Damage(int pType, float pDirection);
 
    proto native    HumanCommandFullBodyDamage  GetCommand_Damage();
 
 
 
 
    proto native    HumanCommandActionCallback  StartCommand_Action(int pActionID, typename pCallbackClass, int pStanceMask);
 
    proto native    HumanCommandActionCallback  GetCommand_Action();
 
    
    //---------------------------------------------------------
    // command modifiers
 
    proto native    int         GetCommandModifierCount();
 
    proto native    int         GetCommandModifierID(int pIndex);   
 
 
 
    proto native    HumanCommandAdditives       GetCommandModifier_Additives();
 
    proto native    HumanCommandWeapons         GetCommandModifier_Weapons();
 
 
 
 
    // --- modifier/additive actions - played on COMMANDID_MOVE command
 
    proto native    HumanCommandActionCallback  AddCommandModifier_Action(int pActionID, typename pCallbackClass);
 
    proto native    void                        DeleteCommandModifier_Action(HumanCommandActionCallback pCallback);
 
    proto native    HumanCommandActionCallback  GetCommandModifier_Action();
 
 
 
 
    // -> of type 0,...
    // -> from direction (lback -180,left -90,0,righ 90,rightback 180)
    proto native    HumanCommandDamage          AddCommandModifier_Damage(int pType, float pDirection);
 
    proto native    void                        DeleteCommandModifier_Damage(HumanCommandDamage pDamage);
 
    proto native    HumanCommandDamage          GetCommandModifier_Damage();
 
 
 
    proto native    HumanCommandScript          StartCommand_Script(HumanCommandScript pHumanCommand);
    proto native    HumanCommandScript          StartCommand_ScriptInst(typename pCallbackClass);
 
    proto native    HumanCommandScript          GetCommand_Script();
 
 
 
    //---------------------------------------------------------
    // debug info for Item Accessor
 
 
    proto native   owned string                         DebugGetItemClass();
 
    proto native   owned string                         DebugGetItemSuperClass();
 
    proto native   owned string                         DebugGetItemAnimInstance();
    
    
    //---------------------------------------------------------
    // helper functions for disabling simulation upon death
    proto native    void StartDeath();
    proto native    void ResetDeath();
 
    proto native    void ResetDeathCooldown();
    proto native    bool IsDeathProcessed();
    proto native    bool IsDeathConditionMet();
 
 
    //--------------------------------------------------------
    // commands start/finish events
    
    void    OnCommandMoveStart();
    void    OnCommandMoveFinish();
 
    void    OnCommandMeleeStart();
    void    OnCommandMeleeFinish();
 
    void    OnCommandMelee2Start();
    void    OnCommandMelee2Finish();
 
    void    OnCommandFallStart();
    void    OnCommandFallFinish();
 
    void    OnCommandClimbStart();
    void    OnCommandClimbFinish();
 
    void    OnCommandDeathStart();
    void    OnCommandDeathFinish();
 
    void    OnCommandUnconsciousStart();
    void    OnCommandUnconsciousFinish();
 
    void    OnCommandDamageFullbodyStart();
    void    OnCommandDamageFullbodyFinish();
 
    void    OnCommandDamageAdditiveStart();
    void    OnCommandDamageAdditiveFinish();
 
    void    OnCommandLadderStart();
    void    OnCommandLadderFinish();
 
    void    OnCommandSwimStart();
    void    OnCommandSwimFinish();
 
    void    OnCommandVehicleStart();
    void    OnCommandVehicleFinish();
 
    void    OnCommandActionFullbodyStart();
    void    OnCommandActionFullbodyFinish();
 
    void    OnCommandActionAdditiveStart();
    void    OnCommandActionAdditiveFinish();
    
    void    OnStanceChange(int previousStance, int newStance);
    
    bool    CanChangeStance(int previousStance, int newStance);
    
    //--------------------------------------------------------
    // rolling API
    
    bool    CanRoll();
    void    OnRollStart(bool isToTheRight);
    void    OnRollFinish();
}