Hand_Events.c

См. документацию.

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 il = GetDst();
        if (!il)
        {
            il = GetSrc();
        }
            
        if (il && !m_Player.GetHumanInventory().HasInventoryReservation(il.GetItem(),il))
        {
            if (m_Player.GetHumanInventory().AddInventoryReservationEx(il.GetItem(), il, GameInventory.c_InventoryReservationTimeoutShortMS))
            {
                return true;
            }
        }
 
        return false;
    }
    
    void ClearInventoryReservation()
    {
        InventoryLocation il = GetDst();
        if (il)
        {
            il = GetSrc();
        }
        
        if (il)
        {
            m_Player.GetHumanInventory().ClearInventoryReservationEx(il.GetItem(), il);
        }
    }
};
 
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 ENABLE_LOGGING
            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 ENABLE_LOGGING
            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 ENABLE_LOGGING
            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 ENABLE_LOGGING
            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 ENABLE_LOGGING
            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 ENABLE_LOGGING
            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 ENABLE_LOGGING
        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().HasInventoryReservation(m_Dst.GetItem(), m_Dst) && !m_Player.GetHumanInventory().HasInventoryReservation(m_Dst2.GetItem(), m_Dst2))
        {
            if (m_Player.GetHumanInventory().AddInventoryReservationEx(m_Dst.GetItem(), m_Dst, GameInventory.c_InventoryReservationTimeoutShortMS))
            {
                if (m_Player.GetHumanInventory().AddInventoryReservationEx(m_Dst2.GetItem(), m_Dst2, GameInventory.c_InventoryReservationTimeoutShortMS))
                {
                    return true;
                }
                else
                {
                    m_Player.GetHumanInventory().ClearInventoryReservationEx(m_Dst.GetItem(), m_Dst);
                }
            }
        }
        return false;
    }
    
    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 ENABLE_LOGGING
            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 ENABLE_LOGGING
        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; }
};