dayzplayerinventory.c

Go to the documentation of this file.

//Post event containers
class DeferredEvent
{
    InventoryMode m_mode;
    bool ReserveInventory(HumanInventory inventory){return true;}
    void ClearInventoryReservation(HumanInventory inventory){}
}
 
 
class DeferredTakeToDst : DeferredEvent
{
    ref InventoryLocation m_src;
    ref InventoryLocation m_dst;
    
    void DeferredTakeToDst(InventoryMode mode, notnull InventoryLocation src, notnull InventoryLocation dst)
    {
        m_mode = mode;
        m_src = src;
        m_dst = dst;
    }
    
    override bool ReserveInventory(HumanInventory inventory)
    {
        if( !inventory.AddInventoryReservationEx(m_dst.GetItem(), m_dst, GameInventory.c_InventoryReservationTimeoutShortMS) )
        {
            return false;
        }
        return true;
    }
    
    override void ClearInventoryReservation(HumanInventory inventory)
    {
        inventory.ClearInventoryReservationEx(m_dst.GetItem(), m_dst);
    }
}
 
class DeferredSwapEntities : DeferredEvent
{
    EntityAI m_item1;
    EntityAI m_item2;
    ref InventoryLocation m_dst1;
    ref InventoryLocation m_dst2;
    
    void DeferredSwapEntities(InventoryMode mode, notnull EntityAI item1, notnull EntityAI item2, notnull InventoryLocation dst1, notnull InventoryLocation dst2)
    {
        m_mode = mode;
        m_item1 = item1;
        m_item2 = item2;
        m_dst1 = dst1;
        m_dst2 = dst2;
    }
    
    override bool ReserveInventory(HumanInventory inventory)
    {
        if( !inventory.AddInventoryReservationEx(m_item1, m_dst1, GameInventory.c_InventoryReservationTimeoutShortMS) )
        {
            return false;
        }
        if( !inventory.AddInventoryReservationEx(m_item2, m_dst2, GameInventory.c_InventoryReservationTimeoutShortMS) )
        {
            inventory.ClearInventoryReservationEx(m_item1, m_dst1);
            return false;
        }
        return true;
    }
    
    override void ClearInventoryReservation(HumanInventory inventory)
    {
        inventory.ClearInventoryReservationEx(m_item1, m_dst1);
        inventory.ClearInventoryReservationEx(m_item2, m_dst2);
    }
}
 
class DeferredForceSwapEntities : DeferredEvent
{
    EntityAI m_item1;
    EntityAI m_item2;
    ref InventoryLocation m_dst1;
    ref InventoryLocation m_dst2;
    
    void DeferredForceSwapEntities(InventoryMode mode, notnull EntityAI item1, notnull EntityAI item2, notnull InventoryLocation dst1, notnull InventoryLocation dst2)
    {
        m_mode = mode;
        m_item1 = item1;
        m_item2 = item2;
        m_dst1 = dst1;
        m_dst2 = dst2;
    }
    
    override bool ReserveInventory(HumanInventory inventory)
    {
        if( !inventory.AddInventoryReservationEx(m_item1, m_dst1, GameInventory.c_InventoryReservationTimeoutShortMS) )
        {
            return false;
        }
        if( !inventory.AddInventoryReservationEx(m_item2, m_dst2, GameInventory.c_InventoryReservationTimeoutShortMS) )
        {
            inventory.ClearInventoryReservationEx(m_item1, m_dst1);
            return false;
        }
        return true;
    }
    
    override void ClearInventoryReservation(HumanInventory inventory)
    {
        inventory.ClearInventoryReservationEx(m_item1, m_dst1);
        inventory.ClearInventoryReservationEx(m_item2, m_dst2);
    }
}
 
class DeferredHandEvent: DeferredEvent
{
    ref HandEventBase m_event;
    void DeferredHandEvent(InventoryMode mode, HandEventBase e)
    {
        m_mode = mode;
        m_event = e;        
    }
    
    override bool ReserveInventory(HumanInventory inventory)
    {
        return m_event.ReserveInventory();
    }
    
    override void ClearInventoryReservation(HumanInventory inventory)
    {
        m_event.ClearInventoryReservation();
    }
}
 
 
class DayZPlayerInventory : HumanInventoryWithFSM
{
    ref DeferredEvent m_DeferredEvent = NULL;
    ref Timer m_DeferredWeaponTimer = new Timer;
    //protected ref HandEventBase m_PostedHandEvent = NULL; /// deferred hand event
    
    
    protected ref HandEventBase m_DeferredPostedHandEvent = NULL; 
    ref WeaponEventBase m_DeferredWeaponEvent = NULL; 
    // states with animations
    protected ref HandAnimatedTakingFromAtt m_Taking;
    protected ref HandAnimatedMovingToAtt m_MovingTo;
    protected ref HandAnimatedSwapping m_Swapping;
    protected ref HandAnimatedForceSwapping m_FSwapping;
    protected ref HandAnimatedForceSwapping_Inst m_FSwappingInst;
 
    void DayZPlayerInventory () 
    {
    }
 
    DayZPlayer GetDayZPlayerOwner () { return DayZPlayer.Cast(GetInventoryOwner()); }
 
    bool IsAuthoritative()
    {
        DayZPlayer player;
        if (!Class.CastTo(player, GetInventoryOwner()))
        {
            return false;
        }
 
        return (player.GetInstanceType() != DayZPlayerInstanceType.INSTANCETYPE_CLIENT && player.GetInstanceType() != DayZPlayerInstanceType.INSTANCETYPE_REMOTE);
    }
 
    bool IsOwner()
    {
        DayZPlayer player;
        if (!Class.CastTo(player, GetInventoryOwner()))
        {
            return false;
        }
 
        return (player.GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_CLIENT || player.GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_AI_SERVER || player.GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_AI_SINGLEPLAYER);
    }
 
    bool IsProxy()
    {
        DayZPlayer player;
        if (!Class.CastTo(player, GetInventoryOwner()))
        {
            return false;
        }
 
        return (player.GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_REMOTE || player.GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_AI_REMOTE);
    }
 
    override void Init ()
    {
        if (LogManager.IsInventoryHFSMLogEnable())
        {
            hndDebugPrint("[hndfsm] Creating DayZPlayer Inventory FSM");
        }
 
        CreateStableStates(); // stable states needs to be created first
 
        m_Taking = new HandAnimatedTakingFromAtt(GetManOwner(), null);
        m_MovingTo = new HandAnimatedMovingToAtt(GetManOwner(), null);
        m_Swapping = new HandAnimatedSwapping(GetManOwner(), null);
        m_FSwapping = new HandAnimatedForceSwapping(GetManOwner(), null);
        m_FSwappingInst = new HandAnimatedForceSwapping_Inst(GetManOwner(), null);
 
        // events
        HandEventBase _fin_ = new HandEventHumanCommandActionFinished;
        HandEventBase _abt_ = new HandEventHumanCommandActionAborted;
        HandEventBase __T__ = new HandEventTake;
        HandEventBase __M__ = new HandEventMoveTo;
        HandEventBase __W__ = new HandEventSwap;
        //HandEventBase __D__ = new HandEventDropping;
        HandEventBase __Xd_ = new HandEventDestroyed;
        HandEventBase __F__ = new HandEventForceSwap;
 
        // setup transitions
        m_FSM.AddTransition(new HandTransition( m_Empty   , __T__,  m_Taking, NULL, new HandSelectAnimationOfTakeToHandsEvent(GetManOwner())));
        m_FSM.AddTransition(new HandTransition( m_Taking  , _fin_,  m_Empty, null, new HandGuardNot(new HandGuardHasItemInHands(GetManOwner()))));
        m_FSM.AddTransition(new HandTransition( m_Taking  , _fin_,  m_Equipped, null, null));
        m_FSM.AddTransition(new HandTransition( m_Taking  , __Xd_,  m_Empty, new HandActionDestroyed, new HandGuardHasDestroyedItemInHands(GetManOwner())));
            m_Taking.AddTransition(new HandTransition(  m_Taking.m_Hide, _abt_,   m_Empty));
            m_Taking.AddTransition(new HandTransition(  m_Taking.m_Show, _abt_,   m_Equipped));
 
        m_FSM.AddTransition(new HandTransition( m_Equipped, __M__,  m_MovingTo, NULL, new HandSelectAnimationOfMoveFromHandsEvent(GetManOwner())));
        m_FSM.AddTransition(new HandTransition( m_MovingTo, __Xd_,  m_Empty, new HandActionDestroyed, new HandGuardHasDestroyedItemInHands(GetManOwner())));
        m_FSM.AddTransition(new HandTransition( m_MovingTo, _fin_,  m_Equipped, null, new HandGuardHasItemInHands(GetManOwner())));
        m_FSM.AddTransition(new HandTransition( m_MovingTo, _fin_,  m_Empty   , null, null));
            m_MovingTo.AddTransition(new HandTransition(  m_MovingTo.m_Hide, _abt_,   m_Equipped));
            m_MovingTo.AddTransition(new HandTransition(  m_MovingTo.m_Show, _abt_,   m_Empty));
 
        m_FSM.AddTransition(new HandTransition( m_Equipped, __W__,  m_Swapping, NULL, new HandSelectAnimationOfSwapInHandsEvent(GetManOwner())));
        m_FSM.AddTransition(new HandTransition( m_Swapping, __Xd_,  m_Empty, new HandActionDestroyed, new HandGuardHasDestroyedItemInHands(GetManOwner())));
        m_FSM.AddTransition(new HandTransition( m_Swapping, _fin_,  m_Empty, null, new HandGuardNot(new HandGuardHasItemInHands(GetManOwner()))));
        m_FSM.AddTransition(new HandTransition( m_Swapping, _fin_,  m_Equipped, null, null));
        m_FSM.AddTransition(new HandTransition( m_Swapping, _abt_,  m_Equipped, null, null));
        
        m_FSM.AddTransition(new HandTransition( m_Equipped, __F__, m_FSwappingInst, NULL, new HandGuardAnd( new HandSelectAnimationOfForceSwapInHandsEvent(GetManOwner()), new HandGuardInstantForceSwap(GetManOwner()) ) ));
        m_FSM.AddTransition(new HandTransition(m_FSwappingInst, _fin_,  m_Equipped, null, new HandGuardHasItemInHands(GetManOwner())));
        m_FSM.AddTransition(new HandTransition(m_FSwappingInst, _fin_,  m_Empty, null, null));
        m_FSM.AddTransition(new HandTransition(m_FSwappingInst, __Xd_,  m_Empty, new HandActionDestroyed, new HandGuardHasDestroyedItemInHands(GetManOwner())));
        m_FSM.AddTransition(new HandTransition( m_FSwappingInst, _abt_,  m_Equipped, null, null));
 
        m_FSM.AddTransition(new HandTransition( m_Equipped, __F__, m_FSwapping, NULL, new HandSelectAnimationOfForceSwapInHandsEvent(GetManOwner())));
        m_FSM.AddTransition(new HandTransition(m_FSwapping, _fin_,  m_Equipped, null, new HandGuardHasItemInHands(GetManOwner())));
        m_FSM.AddTransition(new HandTransition(m_FSwapping, _fin_,  m_Empty, null, null));
        m_FSM.AddTransition(new HandTransition(m_FSwapping, __Xd_,  m_Empty, new HandActionDestroyed, new HandGuardHasDestroyedItemInHands(GetManOwner())));
            m_FSwapping.AddTransition(new HandTransition(  m_FSwapping.m_Start, _abt_,   m_Equipped));
            m_FSwapping.AddTransition(new HandTransition(  m_FSwapping.m_Hide, _abt_,   m_Empty));
            m_FSwapping.AddTransition(new HandTransition(  m_FSwapping.m_Show, _abt_,   m_Equipped));
        
        super.Init(); // initialize ordinary human fsm (no anims)
    }
    
    void CancelHandEvent ()
    {
        m_DeferredPostedHandEvent = null;
        //m_postedHandEvent = null;
    }
    
    void CancelWeaponEvent ()
    {
        m_DeferredWeaponEvent = null;
        m_DeferredWeaponTimer.Stop();
    }
 
    void AbortWeaponEvent ()
    {
        HumanCommandWeapons hcw = GetDayZPlayerOwner().GetCommandModifier_Weapons();
            
        Weapon_Base weapon;
        Class.CastTo(weapon, GetEntityInHands());
            
        if (hcw && weapon && weapon.CanProcessWeaponEvents() && !weapon.IsIdle())
        {
            if (LogManager.IsWeaponLogEnable())
            {
                wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(weapon) + " Weapon event: ABORT! notifying running state=" + weapon.GetCurrentState());
            }
 
            weapon.ProcessWeaponAbortEvent(new WeaponEventHumanCommandActionAborted(GetDayZPlayerOwner()));
        }
    }
    
    void PostWeaponEvent (WeaponEventBase e)
    {
        if (m_DeferredWeaponEvent == NULL)
        {
            m_DeferredWeaponEvent = e;
 
            if (LogManager.IsWeaponLogEnable())
            {
                wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(GetInventoryOwner()) + " Posted event m_DeferredWeaponEvent=" + m_DeferredWeaponEvent.DumpToString());
            }
        }
        else
        {
            Error("[wpnfsm] " + Object.GetDebugName(GetInventoryOwner()) + " warning - pending event already posted, curr_event=" + m_DeferredWeaponEvent.DumpToString() + " new_event=" + e.DumpToString());
        }
    }
    
    void DeferredWeaponFailed()
    {
        Weapon_Base weapon;
        Class.CastTo(weapon, GetEntityInHands());
        
        string secondPart = " - ENTITY IN HANDS IS NOT A WEAPON: " + Object.GetDebugName(GetEntityInHands());
        
        string firstPart = "[wpnfsm] " + Object.GetDebugName(GetInventoryOwner()) + " failed to perform weaponevent " + m_DeferredWeaponEvent.DumpToString();
        if (weapon)
        {
            secondPart = " on " + Object.GetDebugName(GetEntityInHands()) + " which is in state " + weapon.GetCurrentState();
            secondPart += " with physical state: J: " + weapon.IsJammed() + " | ";
            for (int i = 0; i < weapon.GetMuzzleCount(); ++i)
            {
                secondPart += "Chamber_" + i + ": B(" + weapon.IsChamberFull(i) + ") F(" + weapon.IsChamberFiredOut(i) + ") E(" + weapon.IsChamberEmpty(i) + ") | ";
                secondPart += "Magazine_" + i + ": " + weapon.GetMagazine(i);
                if (i < weapon.GetMuzzleCount() - 1)
                    secondPart += " | ";
            }
        }
        
        Error(firstPart + secondPart);
        CancelWeaponEvent();
    }
 
    void HandleWeaponEvents (float dt, out bool exitIronSights)
    {
        HumanCommandWeapons hcw = GetDayZPlayerOwner().GetCommandModifier_Weapons();
 
        Weapon_Base weapon;
        Class.CastTo(weapon, GetEntityInHands());
        
        if (hcw && weapon && weapon.CanProcessWeaponEvents())
        {
            weapon.GetCurrentState().OnUpdate(dt);
 
            if (LogManager.IsWeaponLogEnable())
            {
                wpnDebugSpamALot("[wpnfsm] " + Object.GetDebugName(weapon) + " HCW: playing A=" + typename.EnumToString(WeaponActions, hcw.GetRunningAction()) + " AT=" + WeaponActionTypeToString(hcw.GetRunningAction(), hcw.GetRunningActionType()) + " fini=" + hcw.IsActionFinished());
            }
 
            if (!weapon.IsIdle())
            {
                while (true)
                {
                    int weaponEventId = hcw.IsEvent();
                    if (weaponEventId == -1)
                    {
                        break;
                    }
 
                    if (weaponEventId == WeaponEvents.CHANGE_HIDE)
                    {
                        break;
                    }
 
                    WeaponEventBase anim_event = WeaponAnimEventFactory(weaponEventId, GetDayZPlayerOwner(), NULL);
                    
                    if (LogManager.IsWeaponLogEnable())
                    {
                        wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(weapon) + " HandleWeapons: event arrived " + typename.EnumToString(WeaponEvents, weaponEventId) + "(" + weaponEventId + ")  fsm_ev=" + anim_event.ToString());
                    }
 
                    if (anim_event != NULL)
                    {
                        weapon.ProcessWeaponEvent(anim_event);
                    }
                }
 
                if (hcw.IsActionFinished())
                {
                    if (weapon.IsWaitingForActionFinish())
                    {
                        if (LogManager.IsWeaponLogEnable())
                        {
                            wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(weapon) + " Weapon event: finished! notifying waiting state=" + weapon.GetCurrentState());
                        }
                        
                        weapon.ProcessWeaponEvent(new WeaponEventHumanCommandActionFinished(GetDayZPlayerOwner()));
                    }
                    else
                    {
                        if (LogManager.IsWeaponLogEnable())
                        {
                            wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(weapon) + " Weapon event: ABORT! notifying running state=" + weapon.GetCurrentState());
                        }
 
                        weapon.ProcessWeaponAbortEvent(new WeaponEventHumanCommandActionAborted(GetDayZPlayerOwner()));
                    }
                }
            }
 
            if (m_DeferredWeaponEvent)
            {
                if (LogManager.IsWeaponLogEnable())
                {
                    wpnDebugPrint("[wpnfsm] " + Object.GetDebugName(weapon) + " Weapon event: deferred " + m_DeferredWeaponEvent.DumpToString());
                }
 
                if (weapon.ProcessWeaponEvent(m_DeferredWeaponEvent))
                {
                    exitIronSights = true;
 
                    if (LogManager.IsWeaponLogEnable())
                    {
                        fsmDebugSpam("[wpnfsm] " + Object.GetDebugName(weapon) + " Weapon event: resetting deferred event" + m_DeferredWeaponEvent.DumpToString());
                    }
 
                    m_DeferredWeaponEvent = NULL;
                    m_DeferredWeaponTimer.Stop();
                }
                else if (!m_DeferredWeaponTimer.IsRunning())
                {
                    m_DeferredWeaponTimer.Run(3, this, "DeferredWeaponFailed");
                }
            }
        }
    }
    
    void HandleInventory(float dt)
    {
        HumanCommandWeapons hcw = GetDayZPlayerOwner().GetCommandModifier_Weapons();
 
        EntityAI ih = GetEntityInHands();
        Weapon_Base weapon;
        Class.CastTo(weapon, ih);
        
        if (hcw)
        {
            m_FSM.GetCurrentState().OnUpdate(dt);
 
            #ifdef DEVELOPER
            if (LogManager.IsInventoryHFSMLogEnable())
            {
                hndDebugSpamALot("[hndfsm] HCW: playing A=" + typename.EnumToString(WeaponActions, hcw.GetRunningAction()) + " AT=" + WeaponActionTypeToString(hcw.GetRunningAction(), hcw.GetRunningActionType()) + " fini=" + hcw.IsActionFinished());
            }
            #endif
            
            if ( !m_FSM.GetCurrentState().IsIdle() || !m_FSM.IsRunning())
            {
                while (true)
                {
                    int weaponEventId = hcw.IsEvent();
                    if (weaponEventId == -1)
                    {
                        break;
                    }
 
                    HandEventBase anim_event = HandAnimEventFactory(weaponEventId, GetManOwner(), NULL);
 
                    #ifdef DEVELOPER
                    if (LogManager.IsInventoryHFSMLogEnable())
                    {
                        hndDebugPrint("[hndfsm] HandleInventory: event arrived " + typename.EnumToString(WeaponEvents, weaponEventId) + "(" + weaponEventId + ")  fsm_ev=" + anim_event.ToString());
                    }
                    #endif
 
                    if (anim_event != NULL)
                    {
                        SyncHandEventToRemote(anim_event);
                        ProcessHandEvent(anim_event);
                    }
                }
 
                if (hcw.IsActionFinished())
                {
                    if (m_FSM.GetCurrentState().IsWaitingForActionFinish())
                    {
                        #ifdef DEVELOPER
                        if (LogManager.IsInventoryHFSMLogEnable())
                        {
                            hndDebugPrint("[hndfsm] Hand-Weapon event: finished! notifying waiting state=" + m_FSM.GetCurrentState());
                        }
                        #endif
 
                        HandEventBase fin_event = new HandEventHumanCommandActionFinished(GetManOwner());
                        SyncHandEventToRemote(fin_event);
                        ProcessHandEvent(fin_event);
                    }
                    else
                    {
                        #ifdef DEVELOPER
                        if (LogManager.IsInventoryHFSMLogEnable())
                        {
                            hndDebugPrint("[hndfsm] Hand-Weapon event: ABORT! notifying running state=" + m_FSM.GetCurrentState());
                        }
                        #endif
 
                        HandEventBase abt_event = new HandEventHumanCommandActionAborted(GetManOwner());
                        SyncHandEventToRemote(abt_event);                       
                        ProcessHandAbortEvent(abt_event);
                        //m_FSM.ProcessHandAbortEvent(new WeaponEventHumanCommandActionAborted(GetManOwner()));
                    }
                }
            }
        }
    }
 
 
 
    override bool OnInventoryJunctureFromServer (ParamsReadContext ctx)
    {
        int tmp = -1;
        ctx.Read(tmp);
 
        if (LogManager.IsSyncLogEnable())
        {
            syncDebugPrint("[syncinv] " + Object.GetDebugName(GetDayZPlayerOwner()) + " store Juncture packet STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp());
        }
        
        StoreJunctureData(ctx);
 
        return true;
    }
    
 
    override bool OnInventoryJunctureRepairFromServer (ParamsReadContext ctx)
    {
/*      InventoryLocation il = new InventoryLocation;
        if (!il.ReadFromContext(ctx) )
            return false;
        
        InventoryLocation il_current = new InventoryLocation;
        
        EntityAI item = il.GetItem();
        item.GetInventory().GetCurrentInventoryLocation(il_current);
        
        if( !il_current.CompareLocationOnly(il))
        {
            LocationMoveEntity(il_current,il);
        }*/
        return true;
    }
    
 
    override void OnInventoryJunctureFailureFromServer(ParamsReadContext ctx)
    {
        if (GetGame().IsDedicatedServer())
        {
            return;
        }
 
        int udtIdentifier = -1;
        if (!ctx.Read(udtIdentifier) || udtIdentifier != INPUT_UDT_INVENTORY)
        {
            return;
        }
 
        InventoryLocation src = new InventoryLocation;
        InventoryLocation dst = new InventoryLocation;
        InventoryLocation temp = new InventoryLocation;
 
        InventoryCommandType type = -1;
        if (!ctx.Read(type))
        {
            return;
        }
 
        switch (type)
        {
            case InventoryCommandType.SYNC_MOVE:
            {
                src.ReadFromContext(ctx);
                dst.ReadFromContext(ctx);
                break;
            }
            case InventoryCommandType.HAND_EVENT:
            {
                HandEventBase e = HandEventBase.CreateHandEventFromContext(ctx);
                src = e.GetSrc();
                dst = e.GetDst();
                break;
            }
            case InventoryCommandType.SWAP:
            {
                src.ReadFromContext(ctx);
                temp.ReadFromContext(ctx);
                dst.ReadFromContext(ctx);
                temp.ReadFromContext(ctx);
                break;
            }
            case InventoryCommandType.FORCESWAP:
            {
                break;
            }
            case InventoryCommandType.DESTROY:
            {
                src.ReadFromContext(ctx);
                break;
            }
        }
 
        InventoryValidationReason reason;
        if (!ctx.Read(reason))
        {
            reason = InventoryValidationReason.UNKNOWN;
        }
 
        OnInventoryFailure(type, reason, src, dst);
    }
 
    override void OnInventoryFailure(InventoryCommandType type, InventoryValidationReason reason, InventoryLocation src, InventoryLocation dst)
    {
        if (reason == InventoryValidationReason.DROP_PREVENTED)
        {
            return;
        }
 
    }
    
    protected void OnHandleStoredJunctureData(ParamsReadContext ctx)
    {
        int tmp = -1;
        ctx.Read(tmp);
 
        if (LogManager.IsSyncLogEnable())
        {
            syncDebugPrint("[syncinv] " + Object.GetDebugName(GetDayZPlayerOwner()) + " handle JunctureData packet STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp());
        }
        
        ProcessInputData(ctx, true, false);
    }
 
    proto native void StoreJunctureData(ParamsReadContext ctx);
 
 
 
    override bool OnInputUserDataProcess(ParamsReadContext ctx)
    {
        if (LogManager.IsSyncLogEnable())
        {
            syncDebugPrint("[syncinv] " + Object.GetDebugName(GetDayZPlayerOwner()) + " store InputUserData packet STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp());
        }
    
        StoreInputUserData(ctx);
        return true;
    }
 
    protected void OnHandleStoredInputUserData(ParamsReadContext ctx)
    {
        int tmp = -1;
        ctx.Read(tmp);
 
        if (LogManager.IsSyncLogEnable())
        {
            syncDebugPrint("[syncinv] " + Object.GetDebugName(GetDayZPlayerOwner()) + " handle InputUserData packet STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp());
        }
        
        ProcessInputData(ctx, false, false);
    }
 
    proto native void StoreInputUserData(ParamsReadContext ctx);
    
    void OnInputUserDataForRemote(ParamsReadContext ctx)
    {
        if (LogManager.IsSyncLogEnable())
        {
            syncDebugPrint("[syncinv] " + Object.GetDebugName(GetDayZPlayerOwner()) + " remote handling InputUserData packet from server");
        }
    
        ProcessInputData(ctx, false, true);
    }
 
    override void OnServerInventoryCommand(ParamsReadContext ctx)
    {
        if (LogManager.IsSyncLogEnable())
        {
            syncDebugPrint("[syncinv] " + Object.GetDebugName(GetDayZPlayerOwner()) + " DZPInventory command from server");
        }
        
        ProcessInputData(ctx, true, true);
    }
 
    bool ValidateSyncMove(inout Serializer ctx, InventoryValidation validation)
    {
        InventoryCommandType type = InventoryCommandType.SYNC_MOVE;
 
        InventoryLocation src = new InventoryLocation;
        InventoryLocation dst = new InventoryLocation;
 
        src.ReadFromContext(ctx);
        dst.ReadFromContext(ctx);
        
        #ifdef DEVELOPER
        if (LogManager.IsInventoryMoveLogEnable())
        {
            Debug.InventoryMoveLog("STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + "src=" + InventoryLocation.DumpToStringNullSafe(src) + " dst=" + InventoryLocation.DumpToStringNullSafe(dst), "SYNC_MOVE" , "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString() );
        }
        #endif
        
        if (validation.m_IsRemote && (!src.GetItem() || !dst.GetItem()))
        {
            
            #ifdef DEVELOPER
            if (LogManager.IsInventoryMoveLogEnable())
            {
                Debug.InventoryMoveLog("Failed - item not in bubble", "SYNC_MOVE" , "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString() );
            }
            #endif
 
            if (LogManager.IsSyncLogEnable())
            {
                syncDebugPrint("[syncinv] HandleInputData remote input (cmd=SYNC_MOVE) dropped, item not in bubble! src=" + InventoryLocation.DumpToStringNullSafe(src) + " dst=" + InventoryLocation.DumpToStringNullSafe(dst));
            }
            
            return true;
        }
 
        EnableMovableOverride(src.GetItem());
 
        if (!validation.m_IsRemote && !validation.m_IsJuncture && !PlayerCheckRequestSrc(src, GameInventory.c_MaxItemDistanceRadius))
        {
            
            #ifdef DEVELOPER
            if (LogManager.IsInventoryMoveLogEnable())
            {
                Debug.InventoryMoveLog("Failed - CheckRequestSrc", "SYNC_MOVE" , "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString() );
            }
            #endif
            
            if (LogManager.IsSyncLogEnable())
            {
                syncDebugPrint("[cheat] HandleInputData man=" + Object.GetDebugName(GetManOwner()) + " failed src check with cmd=" + typename.EnumToString(InventoryCommandType, type) + " src=" + InventoryLocation.DumpToStringNullSafe(src));        
            }
            
            RemoveMovableOverride(src.GetItem());
            return true;
        }
        
        if (!validation.m_IsRemote && !validation.m_IsJuncture && !PlayerCheckRequestDst(src, dst, GameInventory.c_MaxItemDistanceRadius))
        {
            #ifdef DEVELOPER
            if (LogManager.IsInventoryMoveLogEnable())
            {
                Debug.InventoryMoveLog("Failed - CheckMoveToDstRequest", "SYNC_MOVE" , "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString() );
            }
            #endif
 
            if (LogManager.IsSyncLogEnable())
            {
                syncDebugPrint("[cheat] HandleInputData man=" + Object.GetDebugName(GetManOwner()) + " is cheating with cmd=" + typename.EnumToString(InventoryCommandType, type) + " src=" + InventoryLocation.DumpToStringNullSafe(src) + " dst=" + InventoryLocation.DumpToStringNullSafe(dst));
            }
            
            RemoveMovableOverride(src.GetItem());
            return true;
        }
        
        RemoveMovableOverride(src.GetItem());
        
        if (LogManager.IsSyncLogEnable())
        {
            syncDebugPrint("[syncinv] " + Object.GetDebugName(GetDayZPlayerOwner()) + " STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " HandleInputData t=" + GetGame().GetTime() + "ms received cmd=" + typename.EnumToString(InventoryCommandType, type) + " src=" + InventoryLocation.DumpToStringNullSafe(src) + " dst=" + InventoryLocation.DumpToStringNullSafe(dst));
        }
    
        if (!validation.m_IsJuncture && GetDayZPlayerOwner().GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_SERVER)
        {
            JunctureRequestResult result_mv = TryAcquireInventoryJunctureFromServer(GetDayZPlayerOwner(), src, dst);
            if (result_mv == JunctureRequestResult.JUNCTURE_NOT_REQUIRED)
            {
                #ifdef DEVELOPER
                if (LogManager.IsInventoryMoveLogEnable())
                {
                    Debug.InventoryMoveLog("Juncture not required", "SYNC_MOVE" , "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString() );
                }
                #endif
 
 
                LocationSyncMoveEntity(src, dst);
 
                validation.m_Result = InventoryValidationResult.SUCCESS;
                return true;
            }
            else if (result_mv == JunctureRequestResult.JUNCTURE_ACQUIRED)
            {
                #ifdef DEVELOPER
                if (LogManager.IsInventoryMoveLogEnable())
                {
                    Debug.InventoryMoveLog("Juncture sended", "SYNC_MOVE" , "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString() );
                }
                #endif
 
                if (!GameInventory.LocationCanMoveEntity(src, dst))
                {
                    #ifdef DEVELOPER
                    DumpInventoryDebug();
 
                    if (LogManager.IsInventoryMoveLogEnable())
                    {
                        Debug.InventoryMoveLog("Failed - LocationCanMoveEntity - Juncture denied", "SYNC_MOVE" , "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString() );
                    }
                    #endif
 
                    return true;
                }
                
                validation.m_Result = InventoryValidationResult.JUNCTURE;
                EnableMovableOverride(src.GetItem());
                return true;
            }
            else if (result_mv == JunctureRequestResult.JUNCTURE_DENIED)
            {
                #ifdef DEVELOPER
                if ( LogManager.IsInventoryMoveLogEnable() )
                {
                    Debug.InventoryMoveLog("Juncture denied", "SYNC_MOVE" , "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString() );
                }
                #endif
 
                validation.m_Reason = InventoryValidationReason.JUNCTURE_DENIED;
                return true;
            }
            else
            {
                Error("[syncinv] HandleInputData: unexpected return code from AcquireInventoryJunctureFromServer");
 
                return true;
            }
        }
 
        if (GetDayZPlayerOwner().GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_CLIENT)
        {
            ClearInventoryReservationEx(dst.GetItem(), dst);
        }
        
        if (GetDayZPlayerOwner().GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_SERVER)
        {
            CheckForRope(src, dst);
        }
 
        if (!validation.m_IsRemote && !validation.m_IsJuncture && !GameInventory.LocationCanMoveEntitySyncCheck(src, dst))
        {
            #ifdef DEVELOPER
            DumpInventoryDebug();
 
            if (LogManager.IsInventoryMoveLogEnable())
            {
                Debug.InventoryMoveLog("Failed - LocationCanMoveEntity", "SYNC_MOVE" , "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString() );
            }
            #endif
            
            Error("[desync] HandleInputData man=" + Object.GetDebugName(GetManOwner()) + " CANNOT move cmd=" + typename.EnumToString(InventoryCommandType, type) + " src=" + InventoryLocation.DumpToStringNullSafe(src) + " dst=" + InventoryLocation.DumpToStringNullSafe(dst));
            return true;
        }
        
        #ifdef DEVELOPER
        if (LogManager.IsInventoryMoveLogEnable())
        {
            Debug.InventoryMoveLog("Success - LocationSyncMoveEntity", "SYNC_MOVE" , "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString() );
        }
        #endif
 
        LocationSyncMoveEntity(src, dst);
 
        validation.m_Result = InventoryValidationResult.SUCCESS;
        return true;
    }
 
    bool ValidateHandEvent(inout Serializer ctx, InventoryValidation validation)
    {
        InventoryCommandType type = InventoryCommandType.HAND_EVENT;
 
        HandEventBase e = HandEventBase.CreateHandEventFromContext(ctx);
        e.ClearInventoryReservation();
        
        e.m_IsRemote = validation.m_IsRemote;
        e.m_IsJuncture = validation.m_IsJuncture;
 
        EntityAI itemSrc = e.GetSrcEntity();
        EntityAI itemDst = e.GetSecondSrcEntity();
 
        #ifdef DEVELOPER
        if (LogManager.IsInventoryMoveLogEnable())
        {
            Debug.InventoryMoveLog("STS = " + e.m_Player.GetSimulationTimeStamp() + " event= " + e.DumpToString(), "HAND_EVENT" , "n/a", "ProcessInputData", e.m_Player.ToString() );
        }
        #endif
 
        if (validation.m_IsRemote && !e.GetSrcEntity())
        {
            
            #ifdef DEVELOPER
            if (LogManager.IsInventoryMoveLogEnable())
            {
                Debug.InventoryMoveLog("Failed - CheckRequestSrc", "HAND_EVENT" , "n/a", "ProcessInputData", e.m_Player.ToString() );
            }
            #endif
            
            Error("[syncinv] HandleInputData remote input (cmd=HAND_EVENT, event=" + e.DumpToString() + ") dropped, item not in bubble");
                    
            return true;
        }
        
        if (itemSrc)
            RemoveMovableOverride(itemSrc);
        if (itemDst)
            RemoveMovableOverride(itemDst);
 
        if (!validation.m_IsRemote && !validation.m_IsJuncture && !e.CheckRequestSrc())
        {
            #ifdef DEVELOPER
            if (LogManager.IsInventoryMoveLogEnable())
            {
                Debug.InventoryMoveLog("Failed - CheckRequestSrc", "HAND_EVENT" , "n/a", "ProcessInputData", e.m_Player.ToString() );
            }
            #endif
            
            if (!validation.m_IsRemote)
            {
                ctx = new ScriptInputUserData;
                InventoryInputUserData.SerializeHandEvent(ctx, e);
            }
 
            RemoveMovableOverride(itemSrc);
            RemoveMovableOverride(itemDst);
 
            return true;
        }
 
        if (!e.CheckRequestEx(validation))
        {
            #ifdef DEVELOPER
            if (LogManager.IsInventoryMoveLogEnable())
            {
                Debug.InventoryMoveLog("Failed - CheckRequest", "HAND_EVENT" , "n/a", "ProcessInputData", e.m_Player.ToString() );
            }
            #endif
 
 
            ctx = new ScriptInputUserData;
            InventoryInputUserData.SerializeHandEvent(ctx, e);
            
            if (LogManager.IsSyncLogEnable())
            {
                syncDebugPrint("[cheat] HandleInputData man=" + Object.GetDebugName(GetManOwner()) + " STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " is cheating with cmd=" + typename.EnumToString(InventoryCommandType, type) + " event=" + e.DumpToString());
            }
            
            RemoveMovableOverride(itemSrc);
            RemoveMovableOverride(itemDst);
            return true;
        }
        
        if (!validation.m_IsRemote && !e.CanPerformEventEx(validation))
        {
            #ifdef DEVELOPER
            if (LogManager.IsInventoryMoveLogEnable())
            {
                Debug.InventoryMoveLog("Failed - CanPerformEvent", "HAND_EVENT" , "n/a", "ProcessInputData", e.m_Player.ToString() );
            }
            #endif
 
 
            ctx = new ScriptInputUserData;
            InventoryInputUserData.SerializeHandEvent(ctx, e);
            
            if (LogManager.IsSyncLogEnable())
            {
                syncDebugPrint("[desync] HandleInputData man=" + Object.GetDebugName(GetManOwner()) + " CANNOT do cmd=HAND_EVENT e=" + e.DumpToString());
            }
        
            RemoveMovableOverride(itemSrc);
            RemoveMovableOverride(itemDst);
            return true;
        }
        
        RemoveMovableOverride(itemSrc);
        RemoveMovableOverride(itemDst);
 
        if (!validation.m_IsJuncture && GetDayZPlayerOwner().GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_SERVER)
        {
            JunctureRequestResult result_ev = e.AcquireInventoryJunctureFromServer(GetDayZPlayerOwner());
            if (result_ev == JunctureRequestResult.JUNCTURE_NOT_REQUIRED)
            {
                #ifdef DEVELOPER
                if (LogManager.IsInventoryMoveLogEnable())
                {
                    Debug.InventoryMoveLog("Juncture not required", "HAND_EVENT" , "n/a", "ProcessInputData", e.m_Player.ToString() );
                }
                #endif
 
            }
            else if (result_ev == JunctureRequestResult.JUNCTURE_ACQUIRED)
            {
                #ifdef DEVELOPER
                if (LogManager.IsInventoryMoveLogEnable())
                {
                    Debug.InventoryMoveLog("Juncture sended", "HAND_EVENT" , "n/a", "ProcessInputData", e.m_Player.ToString() );
                }
                #endif
                
                ctx = new ScriptInputUserData;
                InventoryInputUserData.SerializeHandEvent(ctx, e);
            
                validation.m_Result = InventoryValidationResult.JUNCTURE;
                
                if (itemSrc)
                    EnableMovableOverride(itemSrc);
                if (itemDst)
                    EnableMovableOverride(itemDst);
                return true;
            }
            else if (result_ev == JunctureRequestResult.JUNCTURE_DENIED)
            {
                #ifdef DEVELOPER
                if (LogManager.IsInventoryMoveLogEnable())
                {
                    Debug.InventoryMoveLog("Juncture denied", "HAND_EVENT" , "n/a", "ProcessInputData", e.m_Player.ToString() );
                }
                #endif
 
                validation.m_Reason = InventoryValidationReason.JUNCTURE_DENIED;
                return true;
            }
            else
            {
                Error("[syncinv] HandleInputData: unexpected return code from AcquireInventoryJunctureFromServer");
                
                return true;
            }
        }
        
        if (GetDayZPlayerOwner().GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_SERVER)
        {
            CheckForRope(e.GetSrc(), e.GetDst());
        }
 
        #ifdef DEVELOPER
        if (LogManager.IsInventoryMoveLogEnable())
        {
            Debug.InventoryMoveLog("Success - ProcessHandEvent", "HAND_EVENT" , "n/a", "ProcessInputData", e.m_Player.ToString() );
        }
        #endif
        
        validation.m_Result = InventoryValidationResult.SUCCESS;
        if (!e.m_Player.GetHumanInventory().ProcessHandEvent(e))
        {
            //result = InventoryValidationResult.FAILURE;
        }
 
        return true;
    }
 
    bool ValidateSwap(inout Serializer ctx, InventoryValidation validation)
    {
        InventoryCommandType type = InventoryCommandType.SWAP;
 
        InventoryLocation src1 = new InventoryLocation;
        InventoryLocation src2 = new InventoryLocation;
 
        InventoryLocation dst1 = new InventoryLocation;
        InventoryLocation dst2 = new InventoryLocation;
 
        bool skippedSwap = false;
        
        src1.ReadFromContext(ctx);
        src2.ReadFromContext(ctx);
        dst1.ReadFromContext(ctx);
        dst2.ReadFromContext(ctx);
        ctx.Read(skippedSwap);
        
        #ifdef DEVELOPER
        if (LogManager.IsInventoryMoveLogEnable())
        {
            Debug.InventoryMoveLog("STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " src1=" + InventoryLocation.DumpToStringNullSafe(src1) + " dst1=" + InventoryLocation.DumpToStringNullSafe(dst1) + " src2=" + InventoryLocation.DumpToStringNullSafe(src2) + " dst2=" + InventoryLocation.DumpToStringNullSafe(dst2), "SWAP" , "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString() ); 
        }
        #endif
 
        if (validation.m_IsRemote && (!src1.GetItem() || !src2.GetItem()))
        {
            if (skippedSwap)
            {
                #ifdef DEVELOPER
                if (LogManager.IsInventoryMoveLogEnable())
                {
                    Debug.InventoryMoveLog("Remote - skipped", "SWAP" , "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString() );
                }
                #endif
/*
                if (LogManager.IsSyncLogEnable())
                {
                    syncDebugPrint("[syncinv] HandleInputData remote input (cmd=SWAP) dropped, swap is skipped");
                }
*/
            }
            else
            {
            
                #ifdef DEVELOPER
                if (LogManager.IsInventoryMoveLogEnable())
                {
                    Debug.InventoryMoveLog("Failed - item1 or item2 not exist", "SWAP" , "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString() );
                }
                #endif
 
                Error("[syncinv] HandleInputData remote input (cmd=SWAP) dropped, item not in bubble");
            }
 
            return true;
        }
                
        EnableMovableOverride(src1.GetItem());
        EnableMovableOverride(src2.GetItem());
        
        if (!validation.m_IsRemote && !validation.m_IsJuncture && !PlayerCheckRequestSrc(src1, GameInventory.c_MaxItemDistanceRadius))
        {
            #ifdef DEVELOPER
            if (LogManager.IsInventoryMoveLogEnable())
            {
                Debug.InventoryMoveLog("Failed - CheckRequestSrc1", "SWAP" , "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString() );
            }
            #endif
            
            if (LogManager.IsSyncLogEnable())
            {
                syncDebugPrint("[cheat] HandleInputData man=" + Object.GetDebugName(GetManOwner()) + " failed src1 check with cmd=" + typename.EnumToString(InventoryCommandType, type) + " src1=" + InventoryLocation.DumpToStringNullSafe(src1));
            }
            
            RemoveMovableOverride(src1.GetItem());
            RemoveMovableOverride(src2.GetItem());
            return true;
        }
 
        if (!validation.m_IsRemote && !validation.m_IsJuncture && !PlayerCheckRequestSrc(src2, GameInventory.c_MaxItemDistanceRadius))
        {
            #ifdef DEVELOPER
            if (LogManager.IsInventoryMoveLogEnable())
            {
                Debug.InventoryMoveLog("Failed - CheckRequestSrc2", "SWAP" , "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString() );
            }
            #endif
            
            if (LogManager.IsSyncLogEnable())
            {
                syncDebugPrint("[cheat] HandleInputData man=" + Object.GetDebugName(GetManOwner()) + " failed src2 check with cmd=" + typename.EnumToString(InventoryCommandType, type) + " src2=" + InventoryLocation.DumpToStringNullSafe(src2));
            }
            
            RemoveMovableOverride(src1.GetItem());
            RemoveMovableOverride(src2.GetItem());
            return true;
        }
 
        if (!validation.m_IsRemote && !validation.m_IsJuncture && !PlayerCheckSwapItemsRequest(src1, src2, dst1, dst2, GameInventory.c_MaxItemDistanceRadius))
        {
            #ifdef DEVELOPER
            if (LogManager.IsInventoryMoveLogEnable())
            {
                Debug.InventoryMoveLog("Failed - CheckSwapItemsRequest", "SWAP" , "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString() );
            }
            #endif
            
            if (LogManager.IsSyncLogEnable())
            {
                syncDebugPrint("[cheat] HandleInputData man=" + Object.GetDebugName(GetManOwner()) + " is cheating with cmd=" + typename.EnumToString(InventoryCommandType, type) + " src1=" + InventoryLocation.DumpToStringNullSafe(src1) + " src2=" + InventoryLocation.DumpToStringNullSafe(src2) +  " dst1=" + InventoryLocation.DumpToStringNullSafe(dst1) + " dst2=" + InventoryLocation.DumpToStringNullSafe(dst2));
            }
            
            RemoveMovableOverride(src1.GetItem());
            RemoveMovableOverride(src2.GetItem());
            return true;
        }
                
        RemoveMovableOverride(src1.GetItem());
        RemoveMovableOverride(src2.GetItem());
        
        if (GetDayZPlayerOwner().GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_CLIENT)
        {
            ClearInventoryReservationEx(dst1.GetItem(), dst1);
            ClearInventoryReservationEx(dst2.GetItem(), dst2);
        }               
        
        if (!validation.m_IsRemote && !validation.m_IsJuncture && !GameInventory.CanForceSwapEntitiesEx(src1.GetItem(), dst1, src2.GetItem(), dst2))
        {
            #ifdef DEVELOPER
            DumpInventoryDebug();
                
            if (LogManager.IsInventoryMoveLogEnable())
            {
                Debug.InventoryMoveLog("Failed - CanForceSwapEntitiesEx", "SWAP" , "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString() );
            }
            #endif
            
            Error("[desync] HandleInputData man=" + Object.GetDebugName(GetManOwner()) + " CANNOT swap cmd=" + typename.EnumToString(InventoryCommandType, type) + " src1=" + InventoryLocation.DumpToStringNullSafe(src1) + " dst1=" + InventoryLocation.DumpToStringNullSafe(dst1) +" | src2=" + InventoryLocation.DumpToStringNullSafe(src2) + " dst2=" + InventoryLocation.DumpToStringNullSafe(dst2));
            return true;
        }
    
        if (GetDayZPlayerOwner().GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_CLIENT)
        {
            AddInventoryReservationEx(dst1.GetItem(), dst1, GameInventory.c_InventoryReservationTimeoutShortMS);
            AddInventoryReservationEx(dst2.GetItem(), dst2, GameInventory.c_InventoryReservationTimeoutShortMS);
        }
 
        if (!(src1.IsValid() && src2.IsValid() && dst1.IsValid() && dst2.IsValid()))
        {
            Error("HandleInputData: cmd=" + typename.EnumToString(InventoryCommandType, type) + " invalid input(s): src1=" + InventoryLocation.DumpToStringNullSafe(src1) + " src2=" + InventoryLocation.DumpToStringNullSafe(src2) +  " dst1=" + InventoryLocation.DumpToStringNullSafe(dst1) + " dst2=" + InventoryLocation.DumpToStringNullSafe(dst2));  
            return true;
        }
 
        if (!validation.m_IsJuncture && GetDayZPlayerOwner().GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_SERVER)
        {
            JunctureRequestResult result_sw = TryAcquireTwoInventoryJuncturesFromServer(GetDayZPlayerOwner(), src1, src2, dst1, dst2);
            if (result_sw == JunctureRequestResult.JUNCTURE_NOT_REQUIRED)
            {
                #ifdef DEVELOPER
                if (LogManager.IsInventoryMoveLogEnable())
                {
                    Debug.InventoryMoveLog("Juncture not required", "SWAP" , "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString() );
                }
                #endif
 
            }
            else if (result_sw == JunctureRequestResult.JUNCTURE_ACQUIRED)
            {
                #ifdef DEVELOPER
                if (LogManager.IsInventoryMoveLogEnable())
                {
                    Debug.InventoryMoveLog("Juncture sended", "SWAP" , "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString() );
                }
                #endif
 
                validation.m_Result = InventoryValidationResult.JUNCTURE;
                EnableMovableOverride(src1.GetItem());
                EnableMovableOverride(src2.GetItem());
                return true;
            }
            else if (result_sw == JunctureRequestResult.JUNCTURE_DENIED)
            {
                #ifdef DEVELOPER
                if (LogManager.IsInventoryMoveLogEnable())
                {
                    Debug.InventoryMoveLog("Juncture denied", "SWAP" , "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString() );
                }
                #endif
 
                validation.m_Reason = InventoryValidationReason.JUNCTURE_DENIED;
                return true;
            }
            else
            {
                Error("[syncinv] HandleInputData: unexpected return code from TryAcquireTwoInventoryJuncturesFromServer"); return true;
                
                return true;
            }
        }
            
        if (GetDayZPlayerOwner().GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_CLIENT )
        {
            ClearInventoryReservationEx(dst1.GetItem(),dst1);
            ClearInventoryReservationEx(dst2.GetItem(),dst2);
        }
        
        #ifdef DEVELOPER
        if (LogManager.IsInventoryMoveLogEnable())
        {
            Debug.InventoryMoveLog("Success - item swap", "SWAP" , "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString() );
        }
        #endif
 
        bool isNotSkipped = LocationSwap(src1, src2, dst1, dst2);
        
        ctx = new ScriptInputUserData();
        InventoryInputUserData.SerializeSwap(ctx, src1, src2, dst1, dst2, !isNotSkipped);
 
        validation.m_Result = InventoryValidationResult.SUCCESS;
        return true;
    }
 
    bool ValidateDestroy(inout Serializer ctx, InventoryValidation validation)
    {
        InventoryCommandType type = InventoryCommandType.DESTROY;
 
        if (validation.m_IsJuncture)
        {
            return true;
        }
 
        InventoryLocation src = new InventoryLocation;
        src.ReadFromContext(ctx);
        
        #ifdef DEVELOPER
        if (LogManager.IsInventoryMoveLogEnable())
        {
            Debug.InventoryMoveLog("STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " src=" + InventoryLocation.DumpToStringNullSafe(src), "DESTROY" , "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString() );  
        }
        #endif
 
        if (validation.m_IsRemote && !src.GetItem())
        {
            #ifdef DEVELOPER
            if (LogManager.IsInventoryMoveLogEnable())
            {
                Debug.InventoryMoveLog("Failed item not exist", "DESTROY" , "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString() );   
            }
            #endif
 
            Error("[syncinv] HandleInputData remote input (cmd=DESTROY) dropped, item not in bubble");
            return true;
        }
        
        if (!validation.m_IsRemote && !validation.m_IsJuncture && !PlayerCheckRequestSrc(src, GameInventory.c_MaxItemDistanceRadius))
        {
            #ifdef DEVELOPER
            if (LogManager.IsInventoryMoveLogEnable())
            {
                Debug.InventoryMoveLog("Failed CheckRequestSrc", "DESTROY" , "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString() );  
            }
            #endif
 
            return true;
        }
 
        if (!validation.m_IsRemote && !validation.m_IsJuncture && !PlayerCheckDropRequest(src, GameInventory.c_MaxItemDistanceRadius))
        {
            #ifdef DEVELOPER
            if (LogManager.IsInventoryMoveLogEnable())
            {
                Debug.InventoryMoveLog("Failed CheckDropRequest", "DESTROY" , "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString() ); 
            }
            #endif
 
            return true;
        }
 
        #ifdef DEVELOPER
        if (LogManager.IsInventoryMoveLogEnable())
        {
            Debug.InventoryMoveLog("Success ObjectDelete", "DESTROY" , "n/a", "ProcessInputData", GetDayZPlayerOwner().ToString() );    
        }
        #endif
 
        GetGame().ObjectDelete(src.GetItem());
 
        validation.m_Result = InventoryValidationResult.SUCCESS;
        return true;
    }
 
    bool ProcessInputData(ParamsReadContext ctx, bool isJuncture, bool isRemote)
    {
        if (isJuncture && isRemote)
        {
            return false;
        }
 
        int type = -1;
        if (!ctx.Read(type))
        {
            return false;
        }
 
        InventoryValidation validation();
        validation.m_IsJuncture = isJuncture;
        validation.m_IsRemote = isRemote;
 
        Serializer serializer = ctx;
        
        switch (type)
        {
        case InventoryCommandType.USER_RESERVATION_CANCEL:
            if (!ValidateUserReservationCancel(serializer, validation))
            {
                return false;
            }
            break;
        case InventoryCommandType.SYNC_MOVE:
            if (!ValidateSyncMove(serializer, validation))
            {
                return false;
            }
            break;
        case InventoryCommandType.HAND_EVENT:
            if (!ValidateHandEvent(serializer, validation))
            {
                return false;
            }
            break;
        case InventoryCommandType.SWAP:
            if (!ValidateSwap(serializer, validation))
            {
                return false;
            }
            break;
        case InventoryCommandType.DESTROY:
            if (!ValidateDestroy(serializer, validation))
            {
                return false;
            }
            break;
        default:
            break;
        }
 
        bool canSendJuncture = !isJuncture && GetDayZPlayerOwner().GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_SERVER;
        
        switch (validation.m_Result)
        {
        case InventoryValidationResult.FAILED:
            if (canSendJuncture) 
            {
                if (!serializer.CanWrite())
                {
                    ScriptInputUserData writeableSerializer();
                    writeableSerializer.CopyFrom(serializer);
                    serializer = writeableSerializer;
                }
 
                serializer.Write(validation.m_Reason);
 
                GetDayZPlayerOwner().SendSyncJuncture(DayZPlayerSyncJunctures.SJ_INVENTORY_FAILURE, serializer);
            }
            break;
        case InventoryValidationResult.JUNCTURE:
            if (canSendJuncture) 
            {
                GetDayZPlayerOwner().SendSyncJuncture(DayZPlayerSyncJunctures.SJ_INVENTORY, serializer);
                //StoreInputForRemotes(isJuncture, isRemote, serializer);
            }
            else
            {
                Error("InventoryValidationResult.JUNCTURE returned when not possible to send!");
            }
            break;
        case InventoryValidationResult.SUCCESS:
            StoreInputForRemotes(isJuncture, isRemote, serializer);
            break;
        }
 
        return true;
    }
    
    void RemoveMovableOverride(EntityAI item)
    {
        ItemBase itemIB = ItemBase.Cast(item);
        if (itemIB)
            itemIB.SetCanBeMovedOverride(false);
    }
    
    void EnableMovableOverride(EntityAI item)
    {
        ItemBase itemIB = ItemBase.Cast(item);
        if (itemIB)
            itemIB.SetCanBeMovedOverride(true);
    }
    
    // Hacky solution for dealing with fencekit rope related issues, could be fixed by introducing some indicator that this item behaves differently or sth..
    void CheckForRope(InventoryLocation src, InventoryLocation dst)
    {
        Rope rope = Rope.Cast(src.GetItem());
        if (rope)
            rope.SetTargetLocation(dst);
    }
    
    bool IsServerOrLocalPlayer()
    {
        return GetDayZPlayerOwner().GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_SERVER || GetDayZPlayerOwner() == GetGame().GetPlayer());
    }
    
    bool StoreInputForRemotes (bool handling_juncture, bool remote, ParamsReadContext ctx)
    {
        if (!remote && GetDayZPlayerOwner().GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_SERVER)
        {
            #ifdef DEVELOPER
            if (LogManager.IsInventoryMoveLogEnable())
            {
                Debug.InventoryMoveLog("STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp(), "n/a" , "n/a", "StoreInputForRemotes", GetDayZPlayerOwner().ToString() );  
            }
            #endif
 
            GetDayZPlayerOwner().StoreInputForRemotes(ctx); // @NOTE: needs to be called _after_ the operation
            return true;
        }
 
        return false;
    }
    
    override bool TakeToDst (InventoryMode mode, notnull InventoryLocation src, notnull InventoryLocation dst)
    {
        if (GetManOwner().IsAlive() == false)
            return super.TakeToDst(mode, src, dst);
        
        #ifdef DEVELOPER
        if (LogManager.IsInventoryMoveLogEnable())
        {
            Debug.InventoryMoveLog("STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " src=" + InventoryLocation.DumpToStringNullSafe(src) + " dst=" + InventoryLocation.DumpToStringNullSafe(dst), "n/a" , "n/a", "TakeToDst", GetDayZPlayerOwner().ToString() ); 
        }
        #endif
        
        switch (mode)
        {
            case InventoryMode.SERVER:
                if (RedirectToHandEvent(mode, src, dst))
                {
                    #ifdef DEVELOPER
                    if (LogManager.IsInventoryMoveLogEnable())
                    {
                        Debug.InventoryMoveLog("RedirectToHandEvent", "n/a" , "n/a", "TakeToDst", GetDayZPlayerOwner().ToString() );    
                    }
                    #endif
 
                    return true;
                }
                    
 
                if (GetDayZPlayerOwner().NeedInventoryJunctureFromServer(src.GetItem(), src.GetParent(), dst.GetParent()))
                {
                    if (GetGame().AddInventoryJunctureEx(GetDayZPlayerOwner(), src.GetItem(), dst, true, GameInventory.c_InventoryReservationTimeoutMS))
                    {
                        if (LogManager.IsSyncLogEnable())
                        {
                            syncDebugPrint("[syncinv] " + Object.GetDebugName(GetDayZPlayerOwner()) + " STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " DZPI::Take2Dst(" + typename.EnumToString(InventoryMode, mode) + ") got juncture");
                        }
                    }
                    else
                    {
                        #ifdef DEVELOPER
                        if (LogManager.IsInventoryMoveLogEnable())
                        {
                            Debug.InventoryMoveLog("Juncture failed", "n/a" , "n/a", "TakeToDst", GetDayZPlayerOwner().ToString() );    
                        }
                        #endif
 
                        if (LogManager.IsSyncLogEnable())
                        {
                            syncDebugPrint("[syncinv] " + Object.GetDebugName(GetDayZPlayerOwner()) + " STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " DZPI::Take2Dst(" + typename.EnumToString(InventoryMode, mode) + ") got juncture");
                        }
 
                        return false;
                    }
                        
                }
 
                ScriptInputUserData ctx = new ScriptInputUserData;
                InventoryInputUserData.SerializeMove(ctx, InventoryCommandType.SYNC_MOVE, src, dst);
    
                GetDayZPlayerOwner().SendSyncJuncture(DayZPlayerSyncJunctures.SJ_INVENTORY, ctx);
            
                if (LogManager.IsSyncLogEnable())
                {
                    syncDebugPrint("[syncinv] " + Object.GetDebugName(GetDayZPlayerOwner()) + " STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " store input for remote - DZPI::Take2Dst(" + typename.EnumToString(InventoryMode, mode) + " server sync move src=" + InventoryLocation.DumpToStringNullSafe(src) + " dst=" + InventoryLocation.DumpToStringNullSafe(dst));
                }
                
                //GetDayZPlayerOwner().StoreInputForRemotes(ctx); // @TODO: is this right place? maybe in HandleInputData(server=true, ...)
                #ifdef DEVELOPER
                if ( LogManager.IsInventoryMoveLogEnable() )
                {
                    Debug.InventoryMoveLog("Success - store input for remote mode - " + typename.EnumToString(InventoryMode, mode) + " src=" + InventoryLocation.DumpToStringNullSafe(src) + " dst=" + InventoryLocation.DumpToStringNullSafe(dst), "n/a" , "n/a", "TakeToDst", GetDayZPlayerOwner().ToString() );  
                }
                #endif
                return true;
            
            case InventoryMode.LOCAL:
                LocationSyncMoveEntity(src, dst);
                return true;
        }
        if(!super.TakeToDst(mode,src,dst))
        {
            if (!m_DeferredEvent)
            {
                m_DeferredEvent = new DeferredTakeToDst(mode,src,dst);
                if( m_DeferredEvent.ReserveInventory(this) )
                    return true;
            }
            
            m_DeferredEvent = null;
            return false;
        }
        return true;
    }
    
    void HandleTakeToDst( DeferredEvent deferred_event )
    {
        DeferredTakeToDst deferred_take_to_dst = DeferredTakeToDst.Cast(deferred_event);
        if( deferred_take_to_dst )
        {
            #ifdef DEVELOPER
            if ( LogManager.IsInventoryHFSMLogEnable() )
            {   
                Debug.InventoryHFSMLog("STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp(), "n/a" , "n/a", "HandleTakeToDst", GetDayZPlayerOwner().ToString() );
            }
            #endif
            
            deferred_take_to_dst.ClearInventoryReservation(this);
 
            if (LogManager.IsInventoryMoveLogEnable())
            {
                inventoryDebugPrint("[inv] I::Take2Dst(" + typename.EnumToString(InventoryMode, deferred_take_to_dst.m_mode) + ") src=" + InventoryLocation.DumpToStringNullSafe(deferred_take_to_dst.m_src) + " dst=" + InventoryLocation.DumpToStringNullSafe(deferred_take_to_dst.m_dst));
            }
 
            switch (deferred_take_to_dst.m_mode)
            {
                case InventoryMode.PREDICTIVE:
                    #ifdef DEVELOPER
                    if (LogManager.IsInventoryHFSMLogEnable())
                    {   
                        Debug.InventoryHFSMLog("PREDICTIVE ", "n/a" , "n/a", "HandleTakeToDst", GetDayZPlayerOwner().ToString() );
                    }
                    #endif
                
                    if (LocationCanMoveEntity(deferred_take_to_dst.m_src,deferred_take_to_dst.m_dst))
                    {
                        InventoryInputUserData.SendInputUserDataMove(InventoryCommandType.SYNC_MOVE, deferred_take_to_dst.m_src, deferred_take_to_dst.m_dst);
                        LocationSyncMoveEntity(deferred_take_to_dst.m_src, deferred_take_to_dst.m_dst);
                    }
                    else
                    {
                        #ifdef DEVELOPER
                        if (LogManager.IsInventoryMoveLogEnable())
                        {
                            Debug.InventoryMoveLog("Can not move entity (PREDICTIVE) STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " item = " + deferred_take_to_dst.m_dst.GetItem() + " dst=" + InventoryLocation.DumpToStringNullSafe(deferred_take_to_dst.m_dst), "n/a" , "n/a", "HandleTakeToDst", GetDayZPlayerOwner().ToString() );   
                        }
                        #endif
                    }
                    break;
                case InventoryMode.JUNCTURE:
                    #ifdef DEVELOPER
                    if (LogManager.IsInventoryHFSMLogEnable())
                    {   
                        Debug.InventoryHFSMLog("JUNCTURE ", "n/a" , "n/a", "HandleTakeToDst", GetDayZPlayerOwner().ToString());
                    }
                    #endif
                
                    if (LocationCanMoveEntity(deferred_take_to_dst.m_src,deferred_take_to_dst.m_dst))
                    {
                        DayZPlayer player = GetGame().GetPlayer();
                        player.GetHumanInventory().AddInventoryReservationEx(deferred_take_to_dst.m_dst.GetItem(), deferred_take_to_dst.m_dst, GameInventory.c_InventoryReservationTimeoutShortMS);
                        EnableMovableOverride(deferred_take_to_dst.m_dst.GetItem());    
                        InventoryInputUserData.SendInputUserDataMove(InventoryCommandType.SYNC_MOVE, deferred_take_to_dst.m_src, deferred_take_to_dst.m_dst);
                    }
                    else
                    {
                        #ifdef DEVELOPER
                        if (LogManager.IsInventoryMoveLogEnable())
                        {
                            Debug.InventoryMoveLog("Can not move entity (JUNCTURE) STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " item = " + deferred_take_to_dst.m_dst.GetItem() + " dst=" + InventoryLocation.DumpToStringNullSafe(deferred_take_to_dst.m_dst), "n/a" , "n/a", "HandleTakeToDst", GetDayZPlayerOwner().ToString());  
                        }
                        #endif
                    }
                    break;
                case InventoryMode.LOCAL:
                    #ifdef DEVELOPER
                    if (LogManager.IsInventoryHFSMLogEnable())
                    {   
                        Debug.InventoryHFSMLog("LOCAL ", "n/a" , "n/a", "HandleTakeToDst", GetDayZPlayerOwner().ToString());
                    }
                    #endif
                    break;
                case InventoryMode.SERVER:
                    #ifdef DEVELOPER
                    if (LogManager.IsInventoryHFSMLogEnable())
                    {   
                        Debug.InventoryHFSMLog("SERVER ", "n/a" , "n/a", "HandleTakeToDst", GetDayZPlayerOwner().ToString());
                    }
                    #endif
                    break;
                default:
                    Error("HandEvent - Invalid mode");
                    break;
            }
        }
    }
    
    override bool SwapEntities (InventoryMode mode, notnull EntityAI item1, notnull EntityAI item2)
    {
        #ifdef DEVELOPER
        if (LogManager.IsInventoryMoveLogEnable())
        {
            Debug.InventoryMoveLog("STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " item1 = " + item1 + " item2 = " + item2, "n/a" , "n/a", "SwapEntities", GetDayZPlayerOwner().ToString() );  
        }
        #endif
        
        InventoryLocation src1, src2, dst1, dst2;
        if( mode == InventoryMode.LOCAL )
        {
            if (GameInventory.MakeSrcAndDstForSwap(item1, item2, src1, src2, dst1, dst2))
            {
                LocationSwap(src1, src2, dst1, dst2);
                return true;
            }
        }
        
        if(!super.SwapEntities(mode,item1,item2))
        {
            if(!m_DeferredEvent)
            {
                if( GameInventory.MakeSrcAndDstForSwap(item1, item2, src1, src2, dst1, dst2) );
                {
                    m_DeferredEvent = new DeferredSwapEntities(mode, item1, item2, dst1, dst2);
                    if( m_DeferredEvent.ReserveInventory(this) )
                        return true;
                }
            }
            m_DeferredEvent = null;
            return false;
        }
        return true;
    }
    
    void HandleSwapEntities( DeferredEvent deferred_event )
    {
        DeferredSwapEntities deferred_swap_entities = DeferredSwapEntities.Cast(deferred_event);
        if( deferred_swap_entities )
        {
            deferred_swap_entities.ClearInventoryReservation(this);
            InventoryLocation src1, src2, dst1, dst2;
            if (GameInventory.MakeSrcAndDstForSwap(deferred_swap_entities.m_item1, deferred_swap_entities.m_item2, src1, src2, dst1, dst2))
            {
                if (LogManager.IsInventoryMoveLogEnable())
                {
                    inventoryDebugPrint("[inv] I::Swap(" + typename.EnumToString(InventoryMode, deferred_swap_entities.m_mode) + ") src1=" + InventoryLocation.DumpToStringNullSafe(src1) + " src2=" + InventoryLocation.DumpToStringNullSafe(src2) +  " dst1=" + InventoryLocation.DumpToStringNullSafe(deferred_swap_entities.m_dst1) + " dst2=" + InventoryLocation.DumpToStringNullSafe(deferred_swap_entities.m_dst2));
                }
 
                switch (deferred_swap_entities.m_mode)
                {
                    case InventoryMode.PREDICTIVE:
                        if (CanSwapEntitiesEx(deferred_swap_entities.m_dst1.GetItem(),deferred_swap_entities.m_dst2.GetItem()) )
                        {
                            InventoryInputUserData.SendInputUserDataSwap(src1, src2, deferred_swap_entities.m_dst1, deferred_swap_entities.m_dst2);
                            LocationSwap(src1, src2, deferred_swap_entities.m_dst1, deferred_swap_entities.m_dst2);
                        }
                        else
                        {
                            #ifdef DEVELOPER
                            if (LogManager.IsInventoryMoveLogEnable())
                            {
                                Debug.InventoryMoveLog("Can not swap (PREDICTIVE) STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " item1 = " + deferred_swap_entities.m_dst1.GetItem() + " item2 = " + deferred_swap_entities.m_dst2.GetItem() + " dst=" + InventoryLocation.DumpToStringNullSafe(deferred_swap_entities.m_dst2), "n/a" , "n/a", "ForceSwapEntities", GetDayZPlayerOwner().ToString() ); 
                            }
                            #endif
                        }
                        break;
            
                    case InventoryMode.JUNCTURE:
                        if (CanSwapEntitiesEx(deferred_swap_entities.m_dst1.GetItem(),deferred_swap_entities.m_dst2.GetItem()) )
                        {
                            DayZPlayer player = GetGame().GetPlayer();
                            player.GetHumanInventory().AddInventoryReservationEx(deferred_swap_entities.m_dst1.GetItem(), deferred_swap_entities.m_dst1, GameInventory.c_InventoryReservationTimeoutShortMS);
                            player.GetHumanInventory().AddInventoryReservationEx(deferred_swap_entities.m_dst2.GetItem(), deferred_swap_entities.m_dst2, GameInventory.c_InventoryReservationTimeoutShortMS);
                            EnableMovableOverride(deferred_swap_entities.m_dst1.GetItem());
                            EnableMovableOverride(deferred_swap_entities.m_dst2.GetItem());
                            InventoryInputUserData.SendInputUserDataSwap(src1, src2, deferred_swap_entities.m_dst1, deferred_swap_entities.m_dst2);
                        }
                        else
                        {
                            #ifdef DEVELOPER
                            if (LogManager.IsInventoryMoveLogEnable())
                            {
                                Debug.InventoryMoveLog("Can not swap (JUNCTURE) STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " item1 = " + deferred_swap_entities.m_dst1.GetItem() + " item2 = " + deferred_swap_entities.m_dst2.GetItem() + " dst=" + InventoryLocation.DumpToStringNullSafe(deferred_swap_entities.m_dst2), "n/a" , "n/a", "ForceSwapEntities", GetDayZPlayerOwner().ToString() );   
                            }
                            #endif
                        }
                        break;
 
                    case InventoryMode.LOCAL:
                        break;
 
                    default:
                        Error("SwapEntities - HandEvent - Invalid mode");
                }
            }
            else
                Error("SwapEntities - MakeSrcAndDstForSwap - no inv loc");
        }
    }
    
    override bool ForceSwapEntities (InventoryMode mode, notnull EntityAI item1, notnull EntityAI item2, notnull InventoryLocation item2_dst)
    {
        #ifdef DEVELOPER
        if (LogManager.IsInventoryMoveLogEnable())
        {
            Debug.InventoryMoveLog("STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " item1 = " + item1 + " item2 = " + item2 + " dst=" + InventoryLocation.DumpToStringNullSafe(item2_dst), "n/a" , "n/a", "ForceSwapEntities", GetDayZPlayerOwner().ToString() );   
        }
        #endif
        
        if( mode == InventoryMode.LOCAL )
        {
            InventoryLocation src1, src2, dst1;
            if (GameInventory.MakeSrcAndDstForForceSwap(item1, item2, src1, src2, dst1, item2_dst))
            {
                LocationSwap(src1, src2, dst1, item2_dst);
                return true;
            }
            
        }
        
        if(!super.ForceSwapEntities(mode,item1,item2,item2_dst))
        {
            if(!m_DeferredEvent)
            {
                if (GameInventory.MakeSrcAndDstForForceSwap(item1, item2, src1, src2, dst1, item2_dst))
                {
                    m_DeferredEvent = new DeferredForceSwapEntities(mode,item1,item2, dst1, item2_dst);
                    if( m_DeferredEvent.ReserveInventory(this))
                        return true;
 
                }
            }
            m_DeferredEvent = null;
            return false;
        }
        
        return true;
    }
 
    void HandleForceSwapEntities( DeferredEvent deferred_event )
    {
        DeferredForceSwapEntities deferred_force_swap_entities = DeferredForceSwapEntities.Cast(deferred_event);
        if (deferred_force_swap_entities)
        {
            deferred_force_swap_entities.ClearInventoryReservation(this);
            InventoryLocation src1 = new InventoryLocation;
            InventoryLocation src2 = new InventoryLocation;
            deferred_force_swap_entities.m_item1.GetInventory().GetCurrentInventoryLocation(src1);
            deferred_force_swap_entities.m_item2.GetInventory().GetCurrentInventoryLocation(src2);
 
            DayZPlayer player = GetGame().GetPlayer();
 
            if (LogManager.IsInventoryMoveLogEnable())
            {
                inventoryDebugPrint("[inv] I::FSwap(" + typename.EnumToString(InventoryMode, deferred_force_swap_entities.m_mode) + ") src1=" + InventoryLocation.DumpToStringNullSafe(src1) + " src2=" + InventoryLocation.DumpToStringNullSafe(src2) +  " dst1=" + InventoryLocation.DumpToStringNullSafe(deferred_force_swap_entities.m_dst1) + " dst2=" + InventoryLocation.DumpToStringNullSafe(deferred_force_swap_entities.m_dst2));
            }
 
            switch (deferred_force_swap_entities.m_mode)
            {
                case InventoryMode.PREDICTIVE:
                    if (CanForceSwapEntitiesEx(deferred_force_swap_entities.m_dst1.GetItem(),deferred_force_swap_entities.m_dst1,deferred_force_swap_entities.m_dst2.GetItem(), deferred_force_swap_entities.m_dst2))
                    {
                        InventoryInputUserData.SendInputUserDataSwap(src1, src2, deferred_force_swap_entities.m_dst1, deferred_force_swap_entities.m_dst2);
                        LocationSwap(src1, src2, deferred_force_swap_entities.m_dst1, deferred_force_swap_entities.m_dst2);
                    }
                    else
                    {
                        #ifdef DEVELOPER
                        if (LogManager.IsInventoryMoveLogEnable())
                        {
                            Debug.InventoryMoveLog("Can not force swap (PREDICTIVE) STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " item1 = " + deferred_force_swap_entities.m_dst1.GetItem() + " item2 = " + deferred_force_swap_entities.m_dst2.GetItem() + " dst=" + InventoryLocation.DumpToStringNullSafe(deferred_force_swap_entities.m_dst2), "n/a" , "n/a", "ForceSwapEntities", GetDayZPlayerOwner().ToString());  
                        }
                        #endif                      
                    }
                    break;
 
                case InventoryMode.JUNCTURE:
                    if (CanForceSwapEntitiesEx(deferred_force_swap_entities.m_dst1.GetItem(),deferred_force_swap_entities.m_dst1,deferred_force_swap_entities.m_dst2.GetItem(), deferred_force_swap_entities.m_dst2))
                    {   
                        player.GetHumanInventory().AddInventoryReservationEx(deferred_force_swap_entities.m_item1, deferred_force_swap_entities.m_dst1, GameInventory.c_InventoryReservationTimeoutShortMS);
                        player.GetHumanInventory().AddInventoryReservationEx(deferred_force_swap_entities.m_item2, deferred_force_swap_entities.m_dst2, GameInventory.c_InventoryReservationTimeoutShortMS);
                
                        InventoryInputUserData.SendInputUserDataSwap(src1, src2, deferred_force_swap_entities.m_dst1, deferred_force_swap_entities.m_dst2);
                    }
                    else
                    {
                        #ifdef DEVELOPER
                        if (LogManager.IsInventoryMoveLogEnable())
                        {
                            Debug.InventoryMoveLog("Can not force swap (JUNCTURE) STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp() + " item1 = " + deferred_force_swap_entities.m_dst1.GetItem() + " item2 = " + deferred_force_swap_entities.m_dst2.GetItem() + " dst=" + InventoryLocation.DumpToStringNullSafe(deferred_force_swap_entities.m_dst2), "n/a" , "n/a", "ForceSwapEntities", GetDayZPlayerOwner().ToString());    
                        }
                        #endif
                    }
                    break;
 
                case InventoryMode.LOCAL:
                    break;
 
                default:
                    Error("ForceSwapEntities - HandEvent - Invalid mode");
            }
        }
    }
    
    static void SendServerHandEventViaJuncture (notnull DayZPlayer player, HandEventBase e)
    {
        if (GetGame().IsServer())
        {
            if (e.IsServerSideOnly())
            {
                Error("[syncinv] " + Object.GetDebugName(player) + " SendServerHandEventViaJuncture - called on server side event only, e=" + e.DumpToString());
            }
            
            if (player.IsAlive())
            {
                InventoryLocation dst = e.GetDst();
                InventoryLocation src = e.GetSrc();
                if (src.IsValid() && dst.IsValid())
                {
                    if (player.NeedInventoryJunctureFromServer(src.GetItem(), src.GetParent(), dst.GetParent()))
                    {
                        if (LogManager.IsSyncLogEnable())
                        {
                            syncDebugPrint("[syncinv] " + Object.GetDebugName(player) + " STS = " + player.GetSimulationTimeStamp() + " SendServerHandEventViaJuncture(" + typename.EnumToString(InventoryMode, InventoryMode.SERVER) + ") need juncture src=" + InventoryLocation.DumpToStringNullSafe(src) + " dst=" + InventoryLocation.DumpToStringNullSafe(dst));
                        }
 
                        if (GetGame().AddInventoryJunctureEx(player, src.GetItem(), dst, true, GameInventory.c_InventoryReservationTimeoutMS))
                        {
                            if (LogManager.IsSyncLogEnable())
                            {
                                syncDebugPrint("[syncinv] " + Object.GetDebugName(player) + " STS = " + player.GetSimulationTimeStamp() + " SendServerHandEventViaJuncture(" + typename.EnumToString(InventoryMode, InventoryMode.SERVER) + ") got juncture");
                            }
                        }
                        else
                        {
                            if (LogManager.IsSyncLogEnable())
                            {
                                syncDebugPrint("[syncinv] " + Object.GetDebugName(player) + " STS = " + player.GetSimulationTimeStamp() + " SendServerHandEventViaJuncture(" + typename.EnumToString(InventoryMode, InventoryMode.SERVER) + ") !got juncture");
                            }
                        }
                    }
    
                    if (LogManager.IsSyncLogEnable())
                    {
                        syncDebugPrint("[syncinv] " + Object.GetDebugName(player) + " STS = " + player.GetSimulationTimeStamp() + " SendServerHandEventViaJuncture(" + typename.EnumToString(InventoryMode, InventoryMode.SERVER) + " server hand event src=" + InventoryLocation.DumpToStringNullSafe(src) + " dst=" + InventoryLocation.DumpToStringNullSafe(dst));
                    }
 
                    ScriptInputUserData ctx = new ScriptInputUserData;
                    InventoryInputUserData.SerializeHandEvent(ctx, e);
                    player.SendSyncJuncture(DayZPlayerSyncJunctures.SJ_INVENTORY, ctx);
 
                    if (LogManager.IsSyncLogEnable())
                    {
                        syncDebugPrint("[syncinv] " + Object.GetDebugName(player) + " STS = " + player.GetSimulationTimeStamp() + " store input for remote - SendServerHandEventViaJuncture(" + typename.EnumToString(InventoryMode, InventoryMode.SERVER) + " server hand event src=" + InventoryLocation.DumpToStringNullSafe(src) + " dst=" + InventoryLocation.DumpToStringNullSafe(dst));
                    }
 
                    //player.StoreInputForRemotes(ctx); // @TODO: is this right place? maybe in HandleInputData(server=true, ...)
                }
            }
            else
            {
                Error("[syncinv] SendServerHandEventViaJuncture - called on dead player, juncture is for living only");
            }
        }
    }
 
    override void NetSyncCurrentStateID (int id)
    {
        super.NetSyncCurrentStateID(id);
 
        GetDayZPlayerOwner().GetItemAccessor().OnItemInHandsChanged();
    }
 
    override void OnAfterStoreLoad ()
    {
        GetDayZPlayerOwner().GetItemAccessor().OnItemInHandsChanged(true);
    }
 
    bool OnEventForRemoteWeapon (ParamsReadContext ctx)
    {
        if (GetEntityInHands())
        {
            Weapon_Base wpn = Weapon_Base.Cast(GetEntityInHands());
            if (wpn)
            {
                PlayerBase pb = PlayerBase.Cast(GetDayZPlayerOwner());
 
                WeaponEventBase e = CreateWeaponEventFromContext(ctx);
                if (pb && e)
                {
                    pb.GetWeaponManager().SetRunning(true);
        
                    if (LogManager.IsWeaponLogEnable())
                    {
                        fsmDebugSpam("[wpnfsm] " + Object.GetDebugName(wpn) + " recv event from remote: created event=" + e);
                    }
                    
                    if (e.GetEventID() == WeaponEventID.HUMANCOMMAND_ACTION_ABORTED)
                    {
                        wpn.ProcessWeaponAbortEvent(e);
                    }
                    else
                    {
                        wpn.ProcessWeaponEvent(e);
                    }
                    pb.GetWeaponManager().SetRunning(false);
                }
            }
            else
                Error("OnEventForRemoteWeapon - entity in hands, but not weapon. item=" + GetEntityInHands());
        }
        else
            Error("OnEventForRemoteWeapon - no entity in hands");
        return true;
    }
 
 
    bool OnHandEventForRemote (ParamsReadContext ctx)
    {
        HandEventBase e = HandEventBase.CreateHandEventFromContext(ctx);
        if (e)
        {
            if (LogManager.IsInventoryHFSMLogEnable())
            {
                hndDebugSpam("[hndfsm] recv event from remote: created event=" + e);
            }
 
            //m_FSM.ProcessEvent(e);
 
            if (e.GetEventID() == HandEventID.HUMANCOMMAND_ACTION_ABORTED)
            {
                ProcessEventResult aa;
                m_FSM.ProcessAbortEvent(e, aa);
            }
            else
            {
                m_FSM.ProcessEvent(e);
            }
 
            return true;
        }
        return false;
    }
 
    void SyncHandEventToRemote (HandEventBase e)
    {
        DayZPlayer p = GetDayZPlayerOwner();
        if (p && p.GetInstanceType() == DayZPlayerInstanceType.INSTANCETYPE_SERVER)
        {
            ScriptRemoteInputUserData ctx = new ScriptRemoteInputUserData;
 
            ctx.Write(INPUT_UDT_HAND_REMOTE_EVENT);
            e.WriteToContext(ctx);
 
            if (LogManager.IsInventoryHFSMLogEnable())
            {
                hndDebugPrint("[hndfsm] send 2 remote: sending e=" + e + " id=" + e.GetEventID() + " p=" + p + "  e=" + e.DumpToString());
            }
 
            p.StoreInputForRemotes(ctx);
        }
    }
    
    override void OnHandsExitedStableState (HandStateBase src, HandStateBase dst)
    {
        super.OnHandsExitedStableState(src, dst);
 
        if (LogManager.IsInventoryHFSMLogEnable())
        {
            hndDebugPrint("[hndfsm] hand fsm exit stable src=" + src.Type().ToString());
        }
    }
    
    override void OnHandsEnteredStableState (HandStateBase src, HandStateBase dst)
    {
        super.OnHandsEnteredStableState(src, dst);
 
        if (LogManager.IsInventoryHFSMLogEnable())
        {
            hndDebugPrint("[hndfsm] hand fsm entered stable dst=" + dst.Type().ToString());
        }
    }
    
    override void OnHandsStateChanged (HandStateBase src, HandStateBase dst)
    {
        super.OnHandsStateChanged(src, dst);
 
        if (LogManager.IsInventoryHFSMLogEnable())
        {
            hndDebugPrint("[hndfsm] hand fsm changed state src=" + src.Type().ToString() + " ---> dst=" + dst.Type().ToString());
        }
 
        if (src.IsIdle())
            OnHandsExitedStableState(src, dst);
        
        if (dst.IsIdle())
            OnHandsEnteredStableState(src, dst);
 
#ifdef BOT
        PlayerBase p = PlayerBase.Cast(GetDayZPlayerOwner());
        if (p && p.m_Bot)
        {
            p.m_Bot.ProcessEvent(new BotEventOnItemInHandsChanged(p));
        }
#endif
    }
    
    override bool HandEvent(InventoryMode mode, HandEventBase e)
    {
        if (!IsProcessing())
        {
            EntityAI itemInHands = GetEntityInHands();
            
            InventoryLocation handInventoryLocation();
            handInventoryLocation.SetHands(GetInventoryOwner(), itemInHands);
            
            InventoryValidation validation();
            if (e.CanPerformEventEx(validation))
            {
                m_DeferredEvent = new DeferredHandEvent(mode, e);
                if (m_DeferredEvent.ReserveInventory(this))
                {
                    return true;
                }
            }
            
            m_DeferredEvent = null;
 
            if (!GetGame().IsMultiplayer() || GetGame().IsClient())
            {
                OnInventoryFailure(InventoryCommandType.HAND_EVENT, validation.m_Reason, e.GetSrc(), e.GetDst());
            }
            else
            {
                ScriptInputUserData serializer();
 
                InventoryInputUserData.SerializeHandEvent(serializer, e);
                serializer.Write(validation.m_Reason);
 
                GetDayZPlayerOwner().SendSyncJuncture(DayZPlayerSyncJunctures.SJ_INVENTORY_FAILURE, serializer);
            }
        }
        
        return false;
    }
    
    
    void HandleHandEvent(DeferredEvent deferred_event)
    {
        InventoryValidation validation();
        
        DeferredHandEvent deferred_hand_event = DeferredHandEvent.Cast(deferred_event);
        if (deferred_hand_event)
        {
            #ifdef DEVELOPER
            if (LogManager.IsInventoryHFSMLogEnable())
            {   
                Debug.InventoryHFSMLog("STS = " + GetDayZPlayerOwner().GetSimulationTimeStamp(), "n/a" , "n/a", "HandleHandEvent", GetDayZPlayerOwner().ToString());
            }
            #endif
            
            if (LogManager.IsInventoryHFSMLogEnable())
            {
                hndDebugPrint("[inv] HumanInventory::HandEvent(" + typename.EnumToString(InventoryMode, deferred_hand_event.m_mode) + ") ev=" + deferred_hand_event.m_event.DumpToString());
            }
 
            switch (deferred_hand_event.m_mode)
            {
                case InventoryMode.PREDICTIVE:
                    #ifdef DEVELOPER
                    if (LogManager.IsInventoryHFSMLogEnable())
                    {   
                        Debug.InventoryHFSMLog("PREDICTIVE", "n/a" , "n/a", "HandleHandEvent", GetDayZPlayerOwner().ToString());
                    }
                    #endif
 
                    deferred_hand_event.ClearInventoryReservation(this);
                    if (deferred_hand_event.m_event.CanPerformEventEx(validation))
                    {
                        InventoryInputUserData.SendInputUserDataHandEvent(deferred_hand_event.m_event);
                        ProcessHandEvent(deferred_hand_event.m_event);
                    }
                    break;
 
                case InventoryMode.JUNCTURE:
                    #ifdef DEVELOPER
                    if (LogManager.IsInventoryHFSMLogEnable())
                    {   
                        Debug.InventoryHFSMLog("JUNCTURE", "n/a" , "n/a", "HandleHandEvent", GetDayZPlayerOwner().ToString());
                    }
                    #endif
 
                    deferred_hand_event.ClearInventoryReservation(this);
                    if (deferred_hand_event.m_event.CanPerformEventEx(validation))
                    {
                        deferred_hand_event.ReserveInventory(this);
                        InventoryInputUserData.SendInputUserDataHandEvent(deferred_hand_event.m_event);
                    
                        //Functionality to prevent desync when two players perform interfering action at the same time
                        EntityAI itemSrc = deferred_hand_event.m_event.GetSrcEntity();
                        EntityAI itemDst = null;
                        if (deferred_hand_event.m_event.GetDst())
                            itemDst = deferred_hand_event.m_event.GetDst().GetItem();
                        if (itemSrc)
                            EnableMovableOverride(itemSrc);
                        if (itemDst)
                            EnableMovableOverride(itemDst);
                    }
                    break;
 
                case InventoryMode.LOCAL:
                    #ifdef DEVELOPER
                    if (LogManager.IsInventoryHFSMLogEnable())
                    {   
                        Debug.InventoryHFSMLog("LOCAL", "n/a" , "n/a", "HandleHandEvent", GetDayZPlayerOwner().ToString());
                    }
                    #endif
 
                    deferred_hand_event.ClearInventoryReservation(this);
                    ProcessHandEvent(deferred_hand_event.m_event);
                    //PostHandEvent(deferred_hand_event.m_event);
                    break;
            
                case InventoryMode.SERVER:
                    #ifdef DEVELOPER
                    if (LogManager.IsInventoryHFSMLogEnable())
                    {   
                        Debug.InventoryHFSMLog("SERVER", "n/a" , "n/a", "HandleHandEvent", GetDayZPlayerOwner().ToString());
                    }
                    #endif
 
                    if (LogManager.IsInventoryHFSMLogEnable())
                    {
                        hndDebugPrint("[inv] DZPI::HandEvent(" + typename.EnumToString(InventoryMode, deferred_hand_event.m_mode) + ")");
                    }
                    
                    if (!deferred_hand_event.m_event.IsServerSideOnly())
                    {
                        if (GetDayZPlayerOwner().IsAlive())
                        {
                            SendServerHandEventViaJuncture(GetDayZPlayerOwner(), deferred_hand_event.m_event);
                        }
                        else
                        {
                            InventoryInputUserData.SendServerHandEventViaInventoryCommand(GetDayZPlayerOwner(), deferred_hand_event.m_event);
                        }
                    }
                    else
                    {
                        ProcessHandEvent(deferred_hand_event.m_event);
                    }
                    break;
 
                default:
                    Error("HumanInventory::HandEvent - Invalid mode");
            }
        }
    }
    
    override void HandleInventoryManipulation()
    {
        super.HandleInventoryManipulation();
        if(m_DeferredEvent && ScriptInputUserData.CanStoreInputUserData() )
        {
            HandleHandEvent(m_DeferredEvent);
            HandleTakeToDst(m_DeferredEvent);
            HandleSwapEntities(m_DeferredEvent);
            HandleForceSwapEntities(m_DeferredEvent);
        
            m_DeferredEvent = null;
        }
    }
    
    
    
    bool IsProcessing()
    {
        return !m_FSM.GetCurrentState().IsIdle() || m_DeferredEvent || m_DeferredPostedHandEvent;
    }
    
    bool PlayerCheckRequestSrc ( notnull InventoryLocation src, float radius )
    {
        bool result = true;
        
        EntityAI ent = src.GetParent();
        if ( ent )
        {
            PlayerBase player = PlayerBase.Cast(ent.GetHierarchyRootPlayer());
            if (player)
            {
                if ( GetDayZPlayerOwner() != player )
                {
                    if (player.IsAlive())
                    {
                        if (!player.IsRestrained() && !player.IsUnconscious())
                        {
                            return false;
                        }
                    }
                }
            }
        }
        
        if ( result )
        {
            result = CheckRequestSrc( GetManOwner(), src, radius);
        }
        
        return result;
    }
 
    bool PlayerCheckRequestDst ( notnull InventoryLocation src, notnull InventoryLocation dst, float radius )
    {
        bool result = true;
        
        EntityAI ent = dst.GetParent();
        if ( ent )
        {
            PlayerBase player = PlayerBase.Cast(ent.GetHierarchyRootPlayer());
            if (player)
            {
                if ( GetDayZPlayerOwner() != player )
                {
                    if (player.IsAlive())
                    {
                        if (!player.IsRestrained() && !player.IsUnconscious())
                        {
                            return false;
                        }
                    }
                }
            }
        }
        
        if ( result )
        {
            result = CheckMoveToDstRequest( GetManOwner(), src, dst, radius);
        }
        
        return result;
    }   
    
    bool PlayerCheckSwapItemsRequest( notnull InventoryLocation src1,  notnull InventoryLocation src2, notnull InventoryLocation dst1, notnull InventoryLocation dst2, float radius)
    {
        bool result = true;
        
        EntityAI ent = dst1.GetParent();
        PlayerBase player;
        if ( ent )
        {
            player = PlayerBase.Cast(ent.GetHierarchyRootPlayer());
            if (player)
            {
                if ( GetDayZPlayerOwner() != player )
                {
                    if (player.IsAlive())
                    {
                        if (!player.IsRestrained() && !player.IsUnconscious())
                        {
                            return false;
                        }
                    }
                }
            }
        }
        
        ent = dst2.GetParent();
        if ( ent )
        {
            player = PlayerBase.Cast(ent.GetHierarchyRootPlayer());
            if (player)
            {
                if ( GetDayZPlayerOwner() != player )
                {
                    if (player.IsAlive())
                    {
                        if (!player.IsRestrained() && !player.IsUnconscious())
                        {
                            return false;
                        }
                    }
                }
            }
        }
        
        
        if ( result )
        {
            result = CheckSwapItemsRequest( GetManOwner(), src1, src2, dst1, dst2, GameInventory.c_MaxItemDistanceRadius);
        }
        
        return result;
        
    }
    
    bool PlayerCheckDropRequest ( notnull InventoryLocation src, float radius )
    {
        bool result = true;
        
        EntityAI ent = src.GetParent();
        if ( ent )
        {
            PlayerBase player = PlayerBase.Cast(ent.GetHierarchyRootPlayer());
            if (player)
            {
                if ( GetDayZPlayerOwner() != player )
                {
                    if (player.IsAlive())
                    {
                        if (!player.IsRestrained() && !player.IsUnconscious())
                        {
                            return false;
                        }
                    }
                }
            }
        }
        
        if ( result )
        {
            result = CheckDropRequest( GetManOwner(), src, radius);
        }
        
        return result;
    }
};