hand_events.c

Go to the documentation of this file.

 
enum HandEventID
{
 UNKNOWN,
 TAKE,
 MOVETO,
 DROP,
 THROW,
 SWAP,
 FORCESWAP,
 DESTROY,
 CREATED,
 DESTROYED,
 REPLACE,
 REPLACE2,
 REPLACE3,
 REPLACED,
 HUMANCOMMAND_ACTION_FINISHED,
 HUMANCOMMAND_ACTION_ABORTED,
 ANIMEVENT_CHANGE_HIDE
};
 
enum JunctureRequestResult
{
 JUNCTURE_NOT_REQUIRED,
 JUNCTURE_ACQUIRED,
 JUNCTURE_DENIED,
 ERROR,
}
 
class HandEventBase
{
 int m_EventID = 0;
 int m_AnimationID = -1;
 DayZPlayer m_Player;
 ref InventoryLocation m_Src;
 
 bool m_IsJuncture;
 bool m_IsRemote;
 
 void HandEventBase (Man p = null, InventoryLocation src = null) { Class.CastTo(m_Player, p); m_Src = src; }
 HandEventID GetEventID () { return m_EventID; }
 
 bool IsAuthoritative()
 {
 return m_Player && (m_Player.GetInstanceType() != DayZPlayerInstanceType.INSTANCETYPE_CLIENT && m_Player.GetInstanceType() != DayZPlayerInstanceType.INSTANCETYPE_REMOTE);
 }
 
 bool IsOwner()
 {
 return m_Player && (m_Player.GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_CLIENT || m_Player.GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_AI_SERVER || m_Player.GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_AI_SINGLEPLAYER);
 }
 
 bool IsProxy()
 {
 return m_Player && (m_Player.GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_REMOTE || m_Player.GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_AI_REMOTE);
 }
 
 void ReadFromContext (ParamsReadContext ctx) { } // actual read is in CreateHandEventFromContext
 
 void WriteToContext (ParamsWriteContext ctx)
 {
 ctx.Write(m_EventID);
 ctx.Write(m_Player);
 OptionalLocationWriteToContext(m_Src, ctx);
 ctx.Write(m_AnimationID);
 }
 
 InventoryLocation GetSrc () { return m_Src; }
 EntityAI GetSrcEntity ()
 {
 if (m_Src)
 return m_Src.GetItem();
 return null;
 }
 EntityAI GetSecondSrcEntity () { return null; }
 InventoryLocation GetDst () { return null; }
 int GetAnimationID () { return m_AnimationID; }
 bool AcquireInventoryJunctureFromServer (notnull Man player) { return false; }
 bool CheckRequest () { return true; }
 bool CheckRequestEx (InventoryValidation validation)
 {
 if (validation.m_IsRemote || validation.m_IsJuncture)
 return true;
 
 return CheckRequest();
 }
 bool CanPerformEvent () { return true; }
 bool CanPerformEventEx (InventoryValidation validation) { return CanPerformEvent(); }
 bool CheckRequestSrc () { return true; }
 bool IsServerSideOnly () { return false; }
 
 static HandEventBase HandEventFactory (HandEventID id, Man p = null, InventoryLocation src = null)
 {
 switch (id)
 {
 case HandEventID.UNKNOWN: return null;
 case HandEventID.TAKE: return new HandEventTake(p, src);
 case HandEventID.MOVETO: return new HandEventMoveTo(p, src);
 case HandEventID.DROP: return new HandEventDrop(p, src);
 case HandEventID.THROW: return new HandEventThrow(p, src);
 case HandEventID.SWAP: return new HandEventSwap(p, src);
 case HandEventID.FORCESWAP: return new HandEventForceSwap(p, src);
 case HandEventID.DESTROY: return new HandEventDestroy(p, src);
 case HandEventID.CREATED: return new HandEventCreated(p, src);
 case HandEventID.DESTROYED: return new HandEventDestroyed(p, src);
 case HandEventID.REPLACE: return new HandEventDestroyAndReplaceWithNew(p, src);
 case HandEventID.REPLACE2: return new HandEventDestroyAndReplaceWithNewElsewhere(p, src);
 case HandEventID.REPLACE3: return new HandEventDestroyElsewhereAndReplaceWithNewInHands(p, src);
 case HandEventID.REPLACED: return new HandEventReplaced(p, src);
 case HandEventID.ANIMEVENT_CHANGE_HIDE: return HandAnimEventChanged(p, src);
 case HandEventID.HUMANCOMMAND_ACTION_FINISHED : return HandEventHumanCommandActionFinished(p, src);
 case HandEventID.HUMANCOMMAND_ACTION_ABORTED : return HandEventHumanCommandActionAborted(p, src);
 }
 Error("[hndfsm] HandEventFactory - unregistered hand event with id=" + id);
 return null;
 }
 
 static HandEventBase CreateHandEventFromContext (ParamsReadContext ctx)
 {
 int eventID = -1;
 if (!ctx.Read(eventID))
 {
 Error("[hndfsm] CreateHandEventFromContext - cannot read eventID");
 return null;
 }
 Man player;
 if (!ctx.Read(player))
 {
 Error("[hndfsm] CreateHandEventFromContext - cannot read player");
 return null;
 } 
 InventoryLocation src;
 OptionalLocationReadFromContext(src, ctx);
 
 int animID = -1;
 if (!ctx.Read(animID))
 {
 Error("[hndfsm] CreateHandEventFromContext - cannot read animID");
 return null;
 }
 HandEventBase b = HandEventFactory(eventID, player, src);
 if (b)
 {
 b.m_AnimationID = animID;
 b.ReadFromContext(ctx);
 }
 return b;
 }
 
 string DumpToString ()
 {
 string res = "{ HandEv id=" + typename.EnumToString(HandEventID, GetEventID());
 res = res + " pl=" + Object.GetDebugName(m_Player);
 res = res + " src=" + InventoryLocation.DumpToStringNullSafe(m_Src);
 res = res + " }";
 return res;
 }
 
 bool ReserveInventory()
 {
 InventoryLocation dst = GetDst();
 if( dst && !m_Player.GetHumanInventory().AddInventoryReservationEx(dst.GetItem(), dst, GameInventory.c_InventoryReservationTimeoutShortMS) )
 {
 return false;
 }
 return true;
 }
 
 void ClearInventoryReservation()
 {
 InventoryLocation dst = GetDst();
 if(dst)
 {
 m_Player.GetHumanInventory().ClearInventoryReservationEx(dst.GetItem(), dst);
 }
 }
};
 
class HandEventTake extends HandEventBase
{
 void HandEventTake (Man p = null, InventoryLocation src = null) { m_EventID = HandEventID.TAKE; }
 
 override InventoryLocation GetDst ()
 {
 InventoryLocation dst = new InventoryLocation;
 dst.SetHands(m_Player, GetSrcEntity());
 return dst;
 }
 
 override bool CheckRequestSrc ()
 {
 if (false == GameInventory.CheckRequestSrc(m_Player, GetSrc(), GameInventory.c_MaxItemDistanceRadius))
 {
 Debug.InventoryHFSMLog("CANNOT perform", typename.EnumToString(HandEventID, GetEventID()) , "n/a", "CheckRequestSrc", m_Player.ToString() );
 if (LogManager.IsSyncLogEnable()) syncDebugPrint("[cheat] HandleInputData man=" + Object.GetDebugName(m_Player) + " failed src1 check with cmd=" + typename.EnumToString(HandEventID, GetEventID()) + " src1=" + InventoryLocation.DumpToStringNullSafe(GetSrc()));
 return false; // stale packet
 }
 return true;
 }
 
 override bool CheckRequest ()
 {
 return GameInventory.CheckMoveToDstRequest(m_Player, GetSrc(), GetDst(), GameInventory.c_MaxItemDistanceRadius);
 }
 
 override bool CanPerformEventEx(InventoryValidation validation)
 {
 if (validation.m_IsJuncture)
 {
 return true;
 }
 
 if (!GameInventory.LocationCanMoveEntity(GetSrc(), GetDst()))
 {
 #ifdef DEVELOPER
 if ( LogManager.IsInventoryHFSMLogEnable() )
 { 
 Debug.InventoryHFSMLog("CANNOT perform", typename.EnumToString(HandEventID, GetEventID()) , "n/a", "CanPerformEvent", m_Player.ToString() );
 }
 #endif
 //if (LogManager.IsInventoryHFSMLogEnable()) hndDebugPrint("[desync] HandleInputData man=" + Object.GetDebugName(m_Player) + " CANNOT perform ev=" + DumpToString());
 return false;
 }
 
 return super.CanPerformEventEx(validation);
 }
 
 override bool AcquireInventoryJunctureFromServer (notnull Man player)
 {
 InventoryLocation src = GetSrc();
 InventoryLocation dst = GetDst();
 if (src && dst)
 {
 return TryAcquireInventoryJunctureFromServer(player, src, dst);
 }
 Error("[hndfsm] HandEventTake. AcquireInventoryJunctureFromServer: no src or dst for ev=" + DumpToString());
 return JunctureRequestResult.ERROR;
 }
};
 
class HandEventMoveTo extends HandEventBase
{
 ref InventoryLocation m_Dst; 
 
 void HandEventMoveTo (Man p = null, InventoryLocation src = null, InventoryLocation dst = null) { m_EventID = HandEventID.MOVETO; m_Dst = dst; }
 
 override void ReadFromContext (ParamsReadContext ctx)
 {
 m_Dst = new InventoryLocation;
 super.ReadFromContext(ctx);
 m_Dst.ReadFromContext(ctx);
 }
 override void WriteToContext (ParamsWriteContext ctx)
 {
 super.WriteToContext(ctx);
 m_Dst.WriteToContext(ctx);
 }
 
 override InventoryLocation GetDst () { return m_Dst; }
 
 override bool CheckRequestSrc ()
 {
 if (false == GameInventory.CheckRequestSrc(m_Player, GetSrc(), GameInventory.c_MaxItemDistanceRadius))
 {
 if (LogManager.IsSyncLogEnable()) syncDebugPrint("[cheat] HandleInputData man=" + Object.GetDebugName(m_Player) + " failed src1 check with cmd=" + typename.EnumToString(HandEventID, GetEventID()) + " src1=" + InventoryLocation.DumpToStringNullSafe(GetSrc()));
 return false; // stale packet
 }
 return true;
 }
 
 override bool CheckRequest ()
 {
 return GameInventory.CheckMoveToDstRequest(m_Player, GetSrc(), GetDst(), GameInventory.c_MaxItemDistanceRadius);
 }
 
 override bool CanPerformEvent ()
 {
 if (false == GameInventory.LocationCanMoveEntity(GetSrc(), GetDst()))
 {
 #ifdef DEVELOPER
 if ( LogManager.IsInventoryHFSMLogEnable() )
 { 
 Debug.InventoryHFSMLog("CANNOT perform", typename.EnumToString(HandEventID, GetEventID()) , "n/a", "CanPerformEvent", m_Player.ToString() );
 }
 #endif
 return false;
 }
 return true;
 }
 
 override bool AcquireInventoryJunctureFromServer (notnull Man player)
 {
 InventoryLocation src = GetSrc();
 InventoryLocation dst = GetDst();
 if (src && dst)
 {
 return TryAcquireInventoryJunctureFromServer(player, src, dst);
 }
 Error("[hndfsm] HandEventMoveTo. AcquireInventoryJunctureFromServer: no src or dst for ev=" + DumpToString());
 return JunctureRequestResult.ERROR;
 }
 
 override string DumpToString ()
 {
 string res = "{ HandEventMoveTo id=" + typename.EnumToString(HandEventID, GetEventID()) + " pl=" + Object.GetDebugName(m_Player) + " src=" + InventoryLocation.DumpToStringNullSafe(m_Src) + " dst=" + InventoryLocation.DumpToStringNullSafe(m_Dst) + " }";
 return res;
 }
};
 
class HandEventRemove extends HandEventBase
{
 override InventoryLocation GetDst ()
 {
 return m_Dst;
 }
 
 override bool CheckRequestSrc ()
 {
 if (false == GameInventory.CheckRequestSrc(m_Player, GetSrc(), GameInventory.c_MaxItemDistanceRadius))
 {
 #ifdef DEVELOPER
 if ( LogManager.IsInventoryHFSMLogEnable() )
 { 
 Debug.InventoryHFSMLog("Check src - failed, src = " + InventoryLocation.DumpToStringNullSafe(GetSrc()), typename.EnumToString(HandEventID, GetEventID()) , "n/a", "CheckRequestSrc", m_Player.ToString() );
 }
 #endif
 return false; // stale packet
 }
 return true;
 }
 
 override bool CheckRequest ()
 {
 return GameInventory.CheckMoveToDstRequest(m_Player, GetSrc(), GetDst(), GameInventory.c_MaxItemDistanceRadius);
 }
 
 override bool CanPerformEvent ()
 {
 if (false == GameInventory.LocationCanMoveEntity(GetSrc(), GetDst()))
 {
 #ifdef DEVELOPER
 if ( LogManager.IsInventoryHFSMLogEnable() )
 { 
 Debug.InventoryHFSMLog("CANNOT perform", typename.EnumToString(HandEventID, GetEventID()) , "n/a", "CanPerformEvent", m_Player.ToString() );
 }
 #endif
 return false;
 }
 return true;
 }
 
 override bool AcquireInventoryJunctureFromServer (notnull Man player)
 {
 InventoryLocation src = GetSrc();
 InventoryLocation dst = GetDst();
 if (src && dst)
 {
 return TryAcquireInventoryJunctureFromServer(player, src, dst);
 }
 Error("[hndfsm] HandEventThrow. AcquireInventoryJunctureFromServer: no src or dst for ev=" + DumpToString());
 return JunctureRequestResult.ERROR;
 }
 
 ref InventoryLocation m_Dst;
};
 
class HandEventDrop extends HandEventRemove
{
 void HandEventDrop (Man p = null, InventoryLocation src = null)
 {
 m_EventID = HandEventID.DROP;
 m_CanPerformDrop = true;
 }
 
 override void ReadFromContext(ParamsReadContext ctx)
 {
 super.ReadFromContext(ctx);
 
 ctx.Read(m_CanPerformDrop);
 OptionalLocationReadFromContext(m_Dst, ctx);
 if (!m_Dst)
 {
 m_Dst = new InventoryLocation();
 }
 }
 
 override void WriteToContext(ParamsWriteContext ctx)
 {
 super.WriteToContext(ctx);
 
 ctx.Write(m_CanPerformDrop);
 OptionalLocationWriteToContext(m_Dst, ctx);
 }
 
 override bool CheckRequestEx(InventoryValidation validation)
 {
 if (!validation.m_IsJuncture && IsAuthoritative())
 {
 m_CanPerformDrop = GameInventory.SetGroundPosByOwner(m_Player, GetSrcEntity(), m_Dst);
 }
 
 if (!m_CanPerformDrop)
 {
 validation.m_Reason = InventoryValidationReason.DROP_PREVENTED;
 return false;
 }
 
 return super.CheckRequestEx(validation);
 }
 
 override bool CanPerformEventEx(InventoryValidation validation)
 {
 if (!m_CanPerformDrop)
 {
 return false;
 }
 
 if (!validation.m_IsJuncture && !validation.m_IsRemote && !GetDst() && (GetGame().IsMultiplayer() && GetGame().IsClient()))
 {
 return true;
 }
 
 if (!validation.m_IsRemote && !GetDst())
 {
 m_Dst = new InventoryLocation();
 m_CanPerformDrop = GameInventory.SetGroundPosByOwner(m_Player, GetSrcEntity(), m_Dst);
 
 if (!m_CanPerformDrop)
 {
 validation.m_Reason = InventoryValidationReason.DROP_PREVENTED;
 return false;
 }
 }
 
 return super.CanPerformEventEx(validation);
 }
 
 bool m_CanPerformDrop;
};
 
class HandEventThrow extends HandEventRemove
{
 void HandEventThrow (Man p = null, InventoryLocation src = null) 
 {
 m_EventID = HandEventID.THROW; 
 if( src )
 {
 vector mat[4];
 EntityAI entity = GetSrcEntity();
 if (entity)
 {
 m_Dst = new InventoryLocation;
 entity.GetTransform(mat);
 m_Dst.SetGround(entity, mat);
 }
 else
 {
 Error("[hndfsm] HandEventThrow src entity null!");
 }
 }
 }
 
 override void ReadFromContext (ParamsReadContext ctx)
 {
 super.ReadFromContext(ctx);
 
 m_Dst = new InventoryLocation;
 m_Dst.ReadFromContext(ctx);
 
 float x, y, z;
 ctx.Read(x);
 ctx.Read(y);
 ctx.Read(z);
 m_Force[0] = x;
 m_Force[1] = y;
 m_Force[2] = z;
 }
 
 override void WriteToContext (ParamsWriteContext ctx)
 {
 super.WriteToContext(ctx);
 
 m_Dst.WriteToContext(ctx);
 
 ctx.Write(m_Force[0]);
 ctx.Write(m_Force[1]);
 ctx.Write(m_Force[2]);
 }
 
 void SetForce(vector force) { m_Force = force; }
 vector GetForce() { return m_Force; }
 
 vector m_Force; 
};
 
class HandEventSwap extends HandEventBase
{
 // super.m_Src == src location of new item (that will be taken)
 ref InventoryLocation m_Dst; 
 ref InventoryLocation m_Src2; 
 ref InventoryLocation m_Dst2; 
 int m_Animation2ID = -1;
 
 void HandEventSwap (Man p = null, InventoryLocation src = null, InventoryLocation src2 = null, InventoryLocation dst = null, InventoryLocation dst2 = null)
 {
 m_EventID = HandEventID.SWAP; 
 m_Dst = dst;
 m_Src2 = src2;
 m_Dst2 = dst2;
 }
 
 override void ReadFromContext (ParamsReadContext ctx)
 {
 super.ReadFromContext(ctx);
 
 m_Src2 = new InventoryLocation;
 m_Dst = new InventoryLocation;
 m_Dst2 = new InventoryLocation;
 
 m_Src2.ReadFromContext(ctx);
 m_Dst.ReadFromContext(ctx);
 m_Dst2.ReadFromContext(ctx);
 ctx.Read(m_Animation2ID);
 }
 
 override void WriteToContext (ParamsWriteContext ctx)
 {
 super.WriteToContext(ctx);
 
 m_Src2.WriteToContext(ctx);
 m_Dst.WriteToContext(ctx);
 m_Dst2.WriteToContext(ctx);
 ctx.Write(m_Animation2ID);
 }
 
 override InventoryLocation GetDst ()
 {
 return m_Dst;
 }
 
 override EntityAI GetSecondSrcEntity()
 {
 return m_Src2.GetItem();
 }
 
 override bool CheckRequestSrc ()
 {
 //return false;
 
 if (false == GameInventory.CheckRequestSrc(m_Player, GetSrc(), GameInventory.c_MaxItemDistanceRadius))
 {
 if (LogManager.IsSyncLogEnable()) syncDebugPrint("[cheat] HandleInputData man=" + Object.GetDebugName(m_Player) + " failed src1 check with cmd=" + typename.EnumToString(HandEventID, GetEventID()) + " src1=" + InventoryLocation.DumpToStringNullSafe(GetSrc()));
 return false; // stale packet
 }
 if (false == GameInventory.CheckRequestSrc(m_Player, m_Src2, GameInventory.c_MaxItemDistanceRadius))
 {
 if (LogManager.IsSyncLogEnable()) syncDebugPrint("[cheat] HandleInputData man=" + Object.GetDebugName(m_Player) + " failed src2 check with cmd=" + typename.EnumToString(HandEventID, GetEventID()) + " src2=" + InventoryLocation.DumpToStringNullSafe(m_Src2));
 return false; // stale packet
 }
 return true;
 }
 
 override bool CheckRequest ()
 {
 if (!GameInventory.CheckSwapItemsRequest(m_Player, m_Src, m_Src2, m_Dst, m_Dst2, GameInventory.c_MaxItemDistanceRadius))
 { 
 #ifdef DEVELOPER
 if ( LogManager.IsInventoryHFSMLogEnable() )
 { 
 Debug.InventoryHFSMLog("CheckSwapItemsRequest - failed", typename.EnumToString(HandEventID, GetEventID()) , "n/a", "CheckRequest", m_Player.ToString() );
 }
 #endif
 }
 else if (!m_Player.GetHumanInventory().CanAddSwappedEntity(m_Src, m_Src2, m_Dst, m_Dst2))
 { 
 #ifdef DEVELOPER
 if ( LogManager.IsInventoryHFSMLogEnable() )
 { 
 Debug.InventoryHFSMLog("CanAddSwappedEntity - failed", typename.EnumToString(HandEventID, GetEventID()) , "n/a", "CheckRequest", m_Player.ToString() );
 }
 #endif
 }
 else
 return true;
 
 return false;
 }
 
 override bool CanPerformEvent ()
 {
 if (GameInventory.CanForceSwapEntitiesEx(GetSrc().GetItem(), m_Dst, m_Src2.GetItem(), m_Dst2))
 return true;
 
 #ifdef DEVELOPER
 if ( LogManager.IsInventoryHFSMLogEnable() )
 { 
 Debug.InventoryHFSMLog("CANNOT perform", typename.EnumToString(HandEventID, GetEventID()) , "n/a", "CanPerformEvent", m_Player.ToString() );
 }
 #endif
 return false;
 }
 
 override bool AcquireInventoryJunctureFromServer (notnull Man player)
 {
 return TryAcquireTwoInventoryJuncturesFromServer(player, m_Src, m_Src2, m_Dst, m_Dst2);
 }
 
 override string DumpToString ()
 {
 return "{ HandEventSwap id=" + typename.EnumToString(HandEventID, GetEventID()) + " pl=" + Object.GetDebugName(m_Player) + " src1=" + InventoryLocation.DumpToStringNullSafe(m_Src) + " src2=" + InventoryLocation.DumpToStringNullSafe(m_Src2) + " dst1=" + InventoryLocation.DumpToStringNullSafe(m_Dst) + " dst2=" + InventoryLocation.DumpToStringNullSafe(m_Dst2) + " }";
 }
 
 void CheckAndExecuteForceStandUp()
 {
 DayZPlayer player = DayZPlayer.Cast(m_Player);
 player.ForceStandUpForHeavyItemsSwap( m_Src.GetItem(), m_Src2.GetItem() );
 }
 
 override bool ReserveInventory()
 {
 if( !m_Player.GetHumanInventory().AddInventoryReservationEx(m_Dst.GetItem(), m_Dst, GameInventory.c_InventoryReservationTimeoutShortMS) )
 {
 return false;
 }
 if( !m_Player.GetHumanInventory().AddInventoryReservationEx(m_Dst2.GetItem(), m_Dst2, GameInventory.c_InventoryReservationTimeoutShortMS) )
 {
 m_Player.GetHumanInventory().ClearInventoryReservationEx(m_Dst.GetItem(), m_Dst);
 return false;
 }
 return true;
 }
 
 override void ClearInventoryReservation()
 {
 m_Player.GetHumanInventory().ClearInventoryReservationEx(m_Dst.GetItem(), m_Dst);
 m_Player.GetHumanInventory().ClearInventoryReservationEx(m_Dst2.GetItem(), m_Dst2);
 }
};
 
class HandEventForceSwap extends HandEventSwap
{ 
 void HandEventForceSwap (Man p = null, InventoryLocation src = null, InventoryLocation src2 = null, InventoryLocation dst = null, InventoryLocation dst2 = null) { m_EventID = HandEventID.FORCESWAP; }
 
 override bool CheckRequest ()
 {
 bool test1 = false;
 EntityAI inHands = m_Player.GetHumanInventory().GetEntityInHands();
 if (GetSrcEntity() && inHands && m_Dst && m_Dst.IsValid())
 {
 test1 = GameInventory.CheckSwapItemsRequest(m_Player, m_Src, m_Src2, m_Dst, m_Dst2, GameInventory.c_MaxItemDistanceRadius);
 #ifdef DEVELOPER
 if ( LogManager.IsInventoryHFSMLogEnable() )
 {
 if (!test1) 
 Debug.InventoryHFSMLog("CheckSwapItemsRequest failed", typename.EnumToString(HandEventID, GetEventID()) , "n/a", "CheckRequest", m_Player.ToString() );
 }
 #endif
 }
 return test1;
 }
 
 override bool CanPerformEvent ()
 {
 bool test2 = GameInventory.CanForceSwapEntitiesEx(m_Src.GetItem(), m_Dst, m_Src2.GetItem(), m_Dst2); // null here means 'do not search for dst2' (already have valid one from constructor)
 #ifdef DEVELOPER
 if ( LogManager.IsInventoryHFSMLogEnable() )
 {
 if (!test2) 
 Debug.InventoryHFSMLog("CanForceSwapEntitiesEx failed", typename.EnumToString(HandEventID, GetEventID()) , "n/a", "CanPerformEvent", m_Player.ToString() );
 }
 #endif
 return test2;
 }
};
 
class HandEventDestroy extends HandEventBase
{
 void HandEventDestroy (Man p = null, InventoryLocation src = null) { m_EventID = HandEventID.DESTROY; }
 
 override bool IsServerSideOnly () { return true; }
};
 
class HandEventCreated extends HandEventBase
{
 void HandEventCreated (Man p = null, InventoryLocation src = null) { m_EventID = HandEventID.CREATED; }
};
 
class HandEventDestroyed extends HandEventBase
{
 void HandEventDestroyed (Man p = null, InventoryLocation src = null) { m_EventID = HandEventID.DESTROYED; }
};
 
class HandEventReplaceWithNewBase extends HandEventBase
{
 string m_Type;
 ref ReplaceItemWithNewLambdaBase m_Lambda;
 
 void HandEvengReplaceWithNewBase (Man p = null, InventoryLocation src = null, ReplaceItemWithNewLambdaBase lambda = NULL) { m_EventID = HandEventID.REPLACE; m_Lambda = lambda; }
 
 override void ReadFromContext (ParamsReadContext ctx)
 {
 super.ReadFromContext(ctx);
 ctx.Read(m_Type);
 Error("[hndfsm] HandEventDestroyAndReplaceWithNew - Cannot serialize lambda (read)");
 }
 override void WriteToContext (ParamsWriteContext ctx)
 {
 super.WriteToContext(ctx);
 ctx.Write(m_Type);
 Error("[hndfsm] HandEventDestroyAndReplaceWithNew - Cannot serialize lambda (write)");
 }
 
 override bool IsServerSideOnly () { return true; }
 
 override InventoryLocation GetDst ()
 {
 InventoryLocation dst = new InventoryLocation;
 dst.SetHands(m_Player, GetSrcEntity());
 return dst;
 }
 
 override string DumpToString ()
 {
 string res = "{ HandEvenReplaceWithNewBase id=" + typename.EnumToString(HandEventID, GetEventID()) + " pl=" + Object.GetDebugName(m_Player) + " src=" + InventoryLocation.DumpToStringNullSafe(GetSrc()) + " lambda=" + m_Lambda + " dst=" + InventoryLocation.DumpToStringNullSafe(GetDst()) + " }";
 return res;
 }
};
 
class HandEventDestroyAndReplaceWithNew extends HandEventReplaceWithNewBase
{
 void HandEventDestroyAndReplaceWithNew (Man p = null, InventoryLocation src = null, ReplaceItemWithNewLambdaBase lambda = NULL) { m_EventID = HandEventID.REPLACE; m_Lambda = lambda; }
};
 
class HandEventDestroyAndReplaceWithNewElsewhere extends HandEventDestroyAndReplaceWithNew
{
 void HandEventDestroyAndReplaceWithNewElsewhere (Man p = null, InventoryLocation src = null, ReplaceItemWithNewLambdaBase lambda = NULL) { m_EventID = HandEventID.REPLACE3; m_Lambda = lambda; }
};
 
class HandEventDestroyElsewhereAndReplaceWithNewInHands extends HandEventReplaceWithNewBase
{
 void HandEventDestroyElsewhereAndReplaceWithNewInHands (Man p = null, InventoryLocation src = null, ReplaceItemWithNewLambdaBase lambda = NULL) { m_EventID = HandEventID.REPLACE3; m_Lambda = lambda; }
};
 
class HandEventReplaced extends HandEventBase
{
 void HandEventReplaced (Man p = null, InventoryLocation src = null) { m_EventID = HandEventID.REPLACED; }
};
 
// anim events
 
class HandAnimEventChanged extends HandEventBase
{
 void HandAnimEventChanged (Man p = null, InventoryLocation src = null) { m_EventID = HandEventID.ANIMEVENT_CHANGE_HIDE; }
};
 
HandEventBase HandAnimEventFactory (WeaponEvents type, Man p = null, InventoryLocation src = null)
{
 switch (type)
 {
 case WeaponEvents.CHANGE_HIDE: return new HandAnimEventChanged(p, src);
 case WeaponEvents.CHANGE_SHOW: return new HandAnimEventChanged(p, src);
 }
 return null;
}
 
class HandEventHumanCommandActionFinished extends HandEventBase
{
 void HandEventHumanCommandActionFinished (Man p = null, InventoryLocation src = null) { m_EventID = HandEventID.HUMANCOMMAND_ACTION_FINISHED; }
};
class HandEventHumanCommandActionAborted extends HandEventBase
{
 void HandEventHumanCommandActionAborted (Man p = null, InventoryLocation src = null) { m_EventID = HandEventID.HUMANCOMMAND_ACTION_ABORTED; }
};