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();
}