Inventory.c

Go to the documentation of this file.

//-------------------------------------------------------
enum InventoryCommandType
{
    MOVE,                   
    SYNC_MOVE,              
    HAND_EVENT,             
    SWAP,                   
    FORCESWAP,              
    DESTROY,                
    REPLACE,                
    USER_RESERVATION_CANCEL 
};
enum InventoryJunctureType
{
    TAKE,           
    SWAP,           
    //LOAD,         ///< load mag from ground
};
enum InventoryMode
{
    PREDICTIVE,     
    LOCAL,          
    JUNCTURE,       
    SERVER,         
};
 
enum InventoryValidationResult
{
    FAILED,
    JUNCTURE,
    SUCCESS
};
 
enum InventoryValidationReason
{
    UNKNOWN,
    JUNCTURE_DENIED,
    DROP_PREVENTED
};
 
class InventoryValidation
{
    bool m_IsJuncture = false;
    bool m_IsRemote = false;
 
    InventoryValidationResult m_Result = InventoryValidationResult.FAILED;
    InventoryValidationReason m_Reason = InventoryValidationReason.UNKNOWN;
 
    bool IsAuthoritative()
    {
        return !m_IsJuncture && !m_IsRemote;
    }
};
 
enum InventoryCheckContext
{
    DEFAULT,
    SYNC_CHECK,
}
 
enum FindInventoryReservationMode
{
    LEGACY,
    ITEM,
    DST,
    EQUAL,
};
 
class GameInventory
{
    protected static int m_inventory_check_context = InventoryCheckContext.DEFAULT;
 
//-------------------------------------------------------
 
    proto native EntityAI GetInventoryOwner ();
    
#ifdef DEVELOPER
    proto native void DumpInventoryDebug ();
    
    static proto native void DumpStaticInventoryDebug ();
#endif
    
    proto native bool HasEntityInInventory (notnull EntityAI item);
 
    proto native bool EnumerateInventory (InventoryTraversalType tt, out array<EntityAI> items);
 
    proto native int CountInventory ();
 
 
    proto native CargoBase GetCargo ();
    proto native CargoBase GetCargoFromIndex (int index);
    proto native EntityAI CreateEntityInCargo (string typeName);
    proto native EntityAI CreateEntityInCargoEx (string typeName, int idx, int row, int col, bool flip);
 
    proto native bool HasEntityInCargo (notnull EntityAI e);
    proto native bool HasEntityInCargoEx (notnull EntityAI e, int idx, int row, int col);
    proto native bool CanAddEntityInCargo (notnull EntityAI e, bool flip);
    proto native bool CanAddEntityInCargoEx (notnull EntityAI e, int idx, int row, int col, bool flip);
    proto native bool CanAddEntityInCargoExLoc (InventoryLocation loc);
    proto native bool TestAddEntityInCargoEx (notnull EntityAI e, int idx, int row, int col, bool flip, bool do_resevation_check, bool do_item_check, bool do_lock_check, bool do_occupancy_test, bool do_script_check, bool do_script_load_check);
    proto native bool TestAddEntityInCargoExLoc (notnull InventoryLocation loc, bool do_resevation_check, bool do_item_check, bool do_lock_check, bool do_occupancy_test, bool do_script_check, bool do_script_load_check);
    //proto native bool AddEntityInCargo (notnull EntityAI owner, EntityAI cargo);
    //proto native bool AddEntityInCargoEx (notnull EntityAI owner, notnull EntityAI e, int idx, int row, int col);
    proto native bool CanRemoveEntityInCargo (notnull EntityAI e);
    proto native bool CanRemoveEntityInCargoEx (notnull EntityAI e, int idx, int row, int col);
 
 
 
    proto native int GetSlotId (int index);
    proto native int GetSlotIdCount ();
    proto native int GetAttachmentSlotId (int index);
    proto native int GetAttachmentSlotsCount ();
    proto native bool HasInventorySlot (int slotId);
    proto native int AttachmentCount ();
    proto native EntityAI CreateAttachment (string typeName);
    proto native EntityAI CreateAttachmentEx (string typeName, int slotId);
    proto native EntityAI GetAttachmentFromIndex (int index);
    proto native EntityAI FindAttachment (int slot);
    proto native EntityAI FindAttachmentByName (string slotName);
    proto native bool HasAttachment (notnull EntityAI e);
    proto native bool HasAttachmentEx (notnull EntityAI e, int slot);
    proto native bool CanAddAttachment (notnull EntityAI e);
    proto native bool CanAddAttachmentEx (notnull EntityAI e, int slot);
 
    proto native bool CanRemoveAttachment (EntityAI attachment);
    proto native bool CanRemoveAttachmentEx (EntityAI attachment, int slot);
 
    //proto native bool RemoveAttachment(EntityAI attachment);
    //proto native bool RemoveAttachmentEx(EntityAI attachment, int slot);
 
    proto native EntityAI FindPlaceholderForSlot(int slot);
    proto native bool IsPlaceholderEntity (notnull Object e);
 
 
    proto native bool GetCurrentInventoryLocation (out notnull InventoryLocation loc);
 
    proto native bool FindFreeLocationFor (notnull EntityAI item, FindInventoryLocationType flags, out notnull InventoryLocation loc);
    proto native bool FindFreeLocationForEx (notnull EntityAI item, FindInventoryLocationType flags, notnull InventoryLocation exclude, out notnull InventoryLocation loc);
 
    proto native bool FindFirstFreeLocationForNewEntity (string item_type, FindInventoryLocationType flags, out notnull InventoryLocation loc);
 
    proto native int FindFreeLocationsFor (notnull EntityAI item, FindInventoryLocationType flags, out notnull array<ref InventoryLocation> locs);
 
    static proto native EntityAI LocationCreateEntity (notnull InventoryLocation inv_loc, string type, int iSetupFlags, int iRotation);
    static proto native EntityAI LocationCreateLocalEntity (notnull InventoryLocation inv_loc, string type, int iSetupFlags, int iRotation);
    static proto native bool LocationCanAddEntity(notnull InventoryLocation inv_loc);
    
    //Added script check to  LocationCanAddEntity
    static bool LocationCanAddEntityEx(notnull InventoryLocation inv_loc)
    {
        return LocationCanAddEntity (inv_loc);
    }
    
    static proto native bool LocationTestAddEntity(notnull InventoryLocation inv_loc, bool do_resevation_check, bool do_item_check, bool do_lock_check, bool do_occupancy_test, bool do_script_check, bool do_script_load_check);
    static proto native bool LocationCanRemoveEntity(notnull InventoryLocation inv_loc);
    static proto native bool LocationCanMoveEntity(notnull InventoryLocation src, notnull InventoryLocation dst);
    
    static int GetInventoryCheckContext()
    {
        return m_inventory_check_context;
    }
    
    static bool LocationCanMoveEntitySyncCheck(notnull InventoryLocation src, notnull InventoryLocation dst)
    {
        m_inventory_check_context = InventoryCheckContext.SYNC_CHECK;
        bool result = LocationCanMoveEntity(src, dst);
        m_inventory_check_context = InventoryCheckContext.DEFAULT;
        return result;
        
    }
    static proto native EntityAI LocationGetEntity(notnull InventoryLocation inv_loc);
 
    
    bool IsInCargo()
    {
        InventoryLocation lcn = new InventoryLocation;
        GetCurrentInventoryLocation(lcn);
        if ( lcn.GetType() == InventoryLocationType.CARGO)
        {
            return true;
        }
        
        return false;
    }
    
    bool IsAttachment()
    {
        InventoryLocation lcn = new InventoryLocation;
        GetCurrentInventoryLocation(lcn);
        if ( lcn.GetType() == InventoryLocationType.ATTACHMENT)
        {
            return true;
        }
        
        return false;
    }
    
    bool IsCargoInHiearchy()
    {
        InventoryLocation lcn = new InventoryLocation;
        GetCurrentInventoryLocation(lcn);
        EntityAI parent = lcn.GetParent();
        
        while (parent) //while with limit
        {
            if (lcn.GetType() == InventoryLocationType.CARGO || lcn.GetType() == InventoryLocationType.PROXYCARGO)
            {
                return true;
            }
            
            parent.GetInventory().GetCurrentInventoryLocation(lcn);
            parent = lcn.GetParent();
        }
        
        return false;
    }
    
    bool GetCurrentAttachmentSlotInfo(out int slot_id, out string slot_name)
    {
        slot_id = InventorySlots.INVALID;
        slot_name = "";
        InventoryLocation lcn = new InventoryLocation();
        GetCurrentInventoryLocation(lcn);
        if (lcn.GetType() == InventoryLocationType.ATTACHMENT)
        {
            slot_id = lcn.GetSlot();
            slot_name = InventorySlots.GetSlotName(slot_id);
            return true;
        }
        return false;
    }
    
    static void OnServerInventoryCommandStatic (ParamsReadContext ctx)
    {
        int tmp = -1;
        ctx.Read(tmp);
 
        int type = -1;
        if (!ctx.Read(type))
            return;
 
        switch (type)
        {
            case InventoryCommandType.SYNC_MOVE:
            {
                InventoryLocation src = new InventoryLocation;
                InventoryLocation dst = new InventoryLocation;
 
                src.ReadFromContext(ctx);
                dst.ReadFromContext(ctx);
                syncDebugPrint("[syncinv] t=" + GetGame().GetTime() + "ms ServerInventoryCommand cmd=" + typename.EnumToString(InventoryCommandType, type) + " src=" + InventoryLocation.DumpToStringNullSafe(src) + " dst=" + InventoryLocation.DumpToStringNullSafe(dst));
 
                if (!src.GetItem() || !dst.GetItem())
                {
                    LogError("[syncinv] ServerInventoryCommand (cmd=SYNC_MOVE) dropped, item not in bubble");
                    break; // not in bubble
                }
 
                LocationSyncMoveEntity(src, dst);
                break;
            }
 
            case InventoryCommandType.HAND_EVENT:
            {
                HandEventBase e = HandEventBase.CreateHandEventFromContext(ctx);
                syncDebugPrint("[syncinv] t=" + GetGame().GetTime() + "ms ServerInventoryCommand cmd=" + typename.EnumToString(InventoryCommandType, type) + " event=" + e.DumpToString());
                
                if (!e.GetSrcEntity())
                {
                    Error("[syncinv] ServerInventoryCommand (cmd=HAND_EVENT) dropped, item not in bubble");
                    break; // not in bubble
                }
                e.m_Player.GetHumanInventory().ProcessHandEvent(e);
                break;
            }
 
            case InventoryCommandType.FORCESWAP:
            case InventoryCommandType.SWAP:
            {
                InventoryLocation src1 = new InventoryLocation;
                InventoryLocation src2 = new InventoryLocation;
                InventoryLocation dst1 = new InventoryLocation;
                InventoryLocation dst2 = new InventoryLocation;
                src1.ReadFromContext(ctx);
                src2.ReadFromContext(ctx);
                dst1.ReadFromContext(ctx);
                dst2.ReadFromContext(ctx);
        
                if (src1.IsValid() && src2.IsValid() && dst1.IsValid() && dst2.IsValid())
                {
                    syncDebugPrint("[syncinv] t=" + GetGame().GetTime() + "ms ServerInventoryCommand Swap src1=" + InventoryLocation.DumpToStringNullSafe(src1) + " src2=" + InventoryLocation.DumpToStringNullSafe(src2) +  " dst1=" + InventoryLocation.DumpToStringNullSafe(dst1) + " dst2=" + InventoryLocation.DumpToStringNullSafe(dst2));
 
                    LocationSwap(src1, src2, dst1, dst2);
                }
                else
                    Error("ServerInventoryCommand - cannot swap, invalid location input: src1=" + InventoryLocation.DumpToStringNullSafe(src1) + " src2=" + InventoryLocation.DumpToStringNullSafe(src2) +  " dst1=" + InventoryLocation.DumpToStringNullSafe(dst1) + " dst2=" + InventoryLocation.DumpToStringNullSafe(dst2));
 
                break;
            }
        }
    }
 
    static proto native bool LocationAddEntity (notnull InventoryLocation inv_loc);
    static proto native bool LocationRemoveEntity (notnull InventoryLocation inv_loc);
 
    static proto native bool LocationMoveEntity (notnull InventoryLocation src_loc, notnull InventoryLocation dst_loc);
 
    static proto native bool LocationSyncMoveEntity (notnull InventoryLocation src_loc, notnull InventoryLocation dst_loc);
 
    static proto native bool LocationSwap (notnull InventoryLocation src1, notnull InventoryLocation src2, notnull InventoryLocation dst1, notnull InventoryLocation dst2);
 
    static proto native bool ServerLocationMoveEntity (notnull EntityAI item, ParamsWriteContext ctx);
 
    static proto native bool ServerLocationSyncMoveEntity (Man player, notnull EntityAI item, ParamsWriteContext ctx);
 
    static proto native bool ServerLocationSwap (notnull InventoryLocation src1, notnull InventoryLocation src2, notnull InventoryLocation dst1, notnull InventoryLocation dst2, ParamsWriteContext ctx);
 
    static proto native bool ServerHandEvent (notnull Man player, notnull EntityAI item, ParamsWriteContext ctx);
 
    static proto native bool PrepareDropEntityPos(EntityAI owner, notnull EntityAI item, out vector mat[4], bool useValuesInMatrix = false, int conflictCheckDepth = -1);
    static proto native bool TestDropEntityPos(EntityAI owner, notnull EntityAI item, out vector mat[4], bool useValuesInMatrix = false, int conflictCheckDepth = -1);
 
    static proto native bool CanSwapEntities(notnull EntityAI item1, notnull EntityAI item2);
    
    static bool CanSwapEntitiesEx(notnull EntityAI item1, notnull EntityAI item2)
    {
        int slot;
        InventoryLocation il1 = new InventoryLocation;
        InventoryLocation il2 = new InventoryLocation;
        
        item2.GetInventory().GetCurrentInventoryLocation(il2);
        slot = il2.GetSlot();
 
        if( item1.GetQuantity() > item1.GetTargetQuantityMax(slot) )
            return false;
        
        
        item1.GetInventory().GetCurrentInventoryLocation(il1);
        slot = il1.GetSlot();
        
        if( item2.GetQuantity() > item2.GetTargetQuantityMax(slot) )
            return false;
        
        if(!item1.CanSwapEntities(item2, il2, il1) || !item2.CanSwapEntities(item1, il1, il2))
        {
            return false;
        }
        
        return CanSwapEntities(item1,item2);
    }
 
    static proto native bool CanForceSwapEntities(notnull EntityAI item1, InventoryLocation item1_dst, notnull EntityAI item2, out InventoryLocation item2_dst);
    static bool CanForceSwapEntitiesEx(notnull EntityAI item1, InventoryLocation item1_dst, notnull EntityAI item2, out InventoryLocation item2_dst)
    {
        if (!CanForceSwapEntities(item1, item1_dst, item2, item2_dst) )
            return false;
        
        int slot;
        InventoryLocation il = new InventoryLocation;
        
        if ( item1_dst == null)
        {
            item2.GetInventory().GetCurrentInventoryLocation(il);
            slot = il.GetSlot();
        }
        else
        {
            slot = item1_dst.GetSlot();
        }
        
        if ( item1.GetQuantity() > item1.GetTargetQuantityMax(slot) )
            return false;
        
        if ( item2_dst == null)
        {
            item1.GetInventory().GetCurrentInventoryLocation(il);
            slot = il.GetSlot();
        }
        else
        {
            slot = item2_dst.GetSlot();
        }
        
        if (!item1.CanSwapEntities(item2, item2_dst, item1_dst) || !item2.CanSwapEntities(item1, item1_dst, item2_dst))
        {
            return false;
        }
        
        if ( item2.GetQuantity() > item2.GetTargetQuantityMax(slot) )
            return false;
        
        return true;
    }
    
    proto native bool CanAddSwappedEntity(notnull InventoryLocation src1, notnull InventoryLocation src2, notnull InventoryLocation dst1, notnull InventoryLocation dst2);
 
    const int c_InventoryReservationTimeoutMS = 5000;
    const int c_InventoryReservationTimeoutShortMS = 3000;
    
    static proto native bool AddInventoryReservation(EntityAI item, InventoryLocation dst, int timeout_ms);
    bool AddInventoryReservationEx(EntityAI item, InventoryLocation dst, int timeout_ms)
    {
        if (GetGame().IsMultiplayer() && GetGame().IsServer() )
            return true;
        
        bool ret_val = AddInventoryReservation(item, dst, timeout_ms);
        #ifdef DEVELOPER
        if ( LogManager.IsInventoryReservationLogEnable() )
        {
            DayZPlayer player = GetGame().GetPlayer();
            if ( player )
            {
                if (item)
                    Debug.InventoryMoveLog("Reservation result: " + ret_val + " - STS = " + player.GetSimulationTimeStamp() + " / " + item.ToString() + " / " + InventoryLocation.DumpToStringNullSafe(dst), "n/a" , "n/a", "AddInventoryReservation", player.ToString() );
                else
                    Debug.InventoryMoveLog("Reservation result: " + ret_val + " - STS = " + player.GetSimulationTimeStamp() + " / null / " + InventoryLocation.DumpToStringNullSafe(dst), "n/a" , "n/a", "AddInventoryReservation", player.ToString() );
            }
        }
        #endif
        return ret_val;
    }
    
    static proto native bool ExtendInventoryReservation(EntityAI item, InventoryLocation dst, int timeout_ms);
    bool ExtendInventoryReservationEx(EntityAI item, InventoryLocation dst, int timeout_ms)
    { 
        if (GetGame().IsMultiplayer() && GetGame().IsServer() )
            return true;
        
        bool ret_val = ExtendInventoryReservation(item,dst,timeout_ms);
        #ifdef DEVELOPER
        if ( LogManager.IsInventoryReservationLogEnable() )
        {
            DayZPlayer player = GetGame().GetPlayer();
            if ( player )
            {
                if (item)
                    Debug.InventoryMoveLog("Reservation result: " + ret_val + " - STS = " + player.GetSimulationTimeStamp() + " / " + item.ToString() + " / " + InventoryLocation.DumpToStringNullSafe(dst), "n/a" , "n/a", "ExtendInventoryReservation", player.ToString() );
                else
                    Debug.InventoryMoveLog("Reservation result: " + ret_val + " - STS = " + player.GetSimulationTimeStamp() + " / null / " + InventoryLocation.DumpToStringNullSafe(dst), "n/a" , "n/a", "ExtendInventoryReservation", player.ToString() );
            }
        }
        #endif
        return ret_val;
    }
    
    static proto native bool ClearInventoryReservation(EntityAI item, InventoryLocation dst);
    bool ClearInventoryReservationEx(EntityAI item, InventoryLocation dst)
    {
        if (GetGame().IsMultiplayer() && GetGame().IsServer() )
            return true;
        
        bool ret_val = ClearInventoryReservation(item,dst);
        #ifdef DEVELOPER
        if ( LogManager.IsInventoryReservationLogEnable() )
        {
            DayZPlayer player = GetGame().GetPlayer();
            if ( player )
            {
                if (item)
                    Debug.InventoryMoveLog("Reservation cleared result: " + ret_val + " - STS = " + player.GetSimulationTimeStamp() + " / " + item.ToString() + " / " + InventoryLocation.DumpToStringNullSafe(dst), "n/a" , "n/a", "ClearInventoryReservation", player.ToString() );
                else
                    Debug.InventoryMoveLog("Reservation cleared result: " + ret_val + " - STS = " + player.GetSimulationTimeStamp() + " / null / " + InventoryLocation.DumpToStringNullSafe(dst), "n/a" , "n/a", "ClearInventoryReservation", player.ToString() );
            }
        }
        #endif
        return ret_val;
    }
    
    static proto native bool HasInventoryReservation(EntityAI item, InventoryLocation dst);
    static proto native bool HasInventoryReservationCanAdd(EntityAI item, InventoryLocation dst);
    
    static proto native bool HasInventoryReservationEx(EntityAI item, InventoryLocation dst, FindInventoryReservationMode itemMode, FindInventoryReservationMode parentMode);
    static proto native bool GetInventoryReservationCount(EntityAI item, InventoryLocation dst);
 
    proto native bool CanLockInventoryWithKey (notnull EntityAI key);
    proto native bool CanUnlockInventoryWithKey (notnull EntityAI key);
    proto native void LockInventoryWithKey (notnull EntityAI key);
    proto native void UnlockInventoryWithKey (notnull EntityAI key);
    proto native bool HasKeys ();
 
    proto native void LockInventory (int lockType);
    proto native void UnlockInventory (int lockType);
    proto native int GetScriptLockCount ();
    proto native bool IsInventoryUnlocked ();
    proto native bool IsInventoryLocked ();
    proto native bool IsInventoryLockedForLockType (int lockType);
    proto native bool SetSlotLock (int slot, bool locked);
    proto native bool GetSlotLock (int slot);
 
    const float c_MaxItemDistanceRadius = 2.5;
    static proto native bool CheckRequestSrc (notnull Man requestingPlayer, notnull InventoryLocation src, float radius);
    static proto native bool CheckDropRequest (notnull Man requestingPlayer, notnull InventoryLocation src, float radius);
    static proto native bool CheckTakeItemRequest (notnull Man requestingPlayer, notnull InventoryLocation src, notnull InventoryLocation dst, float radius);
    static proto native bool CheckMoveToDstRequest (notnull Man requestingPlayer, notnull InventoryLocation src, notnull InventoryLocation dst, float radius);
    static proto native bool CheckSwapItemsRequest (notnull Man requestingPlayer, notnull InventoryLocation src1, notnull InventoryLocation src2, notnull InventoryLocation dst1, notnull InventoryLocation dst2, float radius);
    static proto native bool CheckManipulatedObjectsDistances (notnull EntityAI e0, notnull EntityAI e1, float radius);
 
 
    void Init ()
    {
        GetInventoryOwner().OnInventoryInit();
    }
 
    bool OnStoreLoad (ParamsReadContext ctx, int version)
    {
        return true;
    }
    void OnAfterStoreLoad () { }
    void OnStoreSave (ParamsWriteContext ctx) { }
 
    void EEInit ()
    {
        InventoryLocation src = new InventoryLocation;
        if (GetCurrentInventoryLocation(src))
        {
            if (src.GetType() == InventoryLocationType.HANDS)
            {
                Man man = Man.Cast(src.GetParent());
                if (man)
                {
                    inventoryDebugPrint("Inventory::EEInit - Man=" + man + " item=" + this);
                    man.GetHumanInventory().OnEntityInHandsCreated(src);
                }
            }
        }
    }
    
    void EEDelete (EntityAI parent)
    {
        EntityAI item = GetInventoryOwner();
        Man player = item.GetHierarchyRootPlayer();
        if (player)
            player.GetInventory().ClearInventoryReservationEx(item, null);
    }
 
    EntityAI CreateInInventory (string type)
    {
        InventoryLocation loc = new InventoryLocation;
        if (FindFirstFreeLocationForNewEntity(type, FindInventoryLocationType.CARGO | FindInventoryLocationType.ATTACHMENT, loc))
        {
            switch (loc.GetType())
            {
                case InventoryLocationType.ATTACHMENT: return loc.GetParent().GetInventory().CreateAttachmentEx(type, loc.GetSlot()); break;
                case InventoryLocationType.CARGO: return loc.GetParent().GetInventory().CreateEntityInCargoEx(type, loc.GetIdx(), loc.GetRow(), loc.GetCol(), loc.GetFlip()); break;
                default: Error("CreateInInventory: unknown location for item"); break;
            }
        }
        return null;
    }
 
    bool CanAddEntityToInventory (notnull EntityAI item, int flag = FindInventoryLocationType.ANY)
    {
        InventoryLocation il = new InventoryLocation;
        bool result = FindFreeLocationFor(item, flag, il);
        return result;
    }
    bool AddEntityToInventory (notnull EntityAI item)
    {
        InventoryLocation il = new InventoryLocation;
        bool result = FindFreeLocationFor(item, FindInventoryLocationType.ANY, il);
        if (result)
            return LocationAddEntity(il);
        return result;
    }
 
    bool CanRemoveEntity ()
    {
        InventoryLocation il = new InventoryLocation;
        if (GetCurrentInventoryLocation(il))
            return LocationCanRemoveEntity(il);
        return false;
    }
 
    // Script version of CanAddEntity* methods based on InventoryLocation
    bool CanAddEntityInto (notnull EntityAI item, FindInventoryLocationType flags = FindInventoryLocationType.ANY)
    {
        InventoryLocation loc = new InventoryLocation;
        return FindFreeLocationFor(item, flags, loc)  &&  !item.IsHologram();
    }
    
    bool CanAddEntityIntoInventory (notnull EntityAI item)
    {
        return CanAddEntityInto(item, FindInventoryLocationType.ANY_CARGO | FindInventoryLocationType.ATTACHMENT);
    }
 
    bool CanAddEntityIntoHands (notnull EntityAI item)
    {
        return CanAddEntityInto(item, FindInventoryLocationType.HANDS);
    }
 
    bool OnInputUserDataProcess(ParamsReadContext ctx) { }
    bool OnInventoryJunctureFromServer(ParamsReadContext ctx) { }
    bool OnInventoryJunctureRepairFromServer(ParamsReadContext ctx) { }
    void OnInventoryJunctureFailureFromServer(ParamsReadContext ctx) { }
    void OnServerInventoryCommand(ParamsReadContext ctx) { }
 
    void OnInventoryFailure(InventoryCommandType type, InventoryValidationReason reason, InventoryLocation src, InventoryLocation dst) {}
 
    bool TakeEntityToInventory (InventoryMode mode, FindInventoryLocationType flags, notnull EntityAI item)
    {
        inventoryDebugPrint("[inv] I::Take2Inv(" + typename.EnumToString(InventoryMode, mode) + ") item=" + item);
 
        InventoryLocation src = new InventoryLocation;
        if (item.GetInventory().GetCurrentInventoryLocation(src))
        {
            InventoryLocation dst = new InventoryLocation;
            if (FindFreeLocationFor(item, flags, dst))
                return TakeToDst(mode, src, dst);
 
            inventoryDebugPrint("[inv] I::Take2Inv(" + typename.EnumToString(InventoryMode, mode) + ") item=" + item + " Warning - no room for item");
            return false;
        }
        Error("[inv] I::Take2Inv(" + typename.EnumToString(InventoryMode, mode) + ") item=" + item + " Error - src has no inventory location");
        return false;
    }
 
    bool TakeEntityToTargetInventory (InventoryMode mode, notnull EntityAI target, FindInventoryLocationType flags, notnull EntityAI item)
    {
        inventoryDebugPrint("[inv] I::Take2Target(" + typename.EnumToString(InventoryMode, mode) + ") item=" + item);
 
        InventoryLocation src = new InventoryLocation;
        if (item.GetInventory().GetCurrentInventoryLocation(src))
        {
            InventoryLocation dst = new InventoryLocation;
                
            if (target.GetInventory().FindFreeLocationFor(item, flags, dst))
                return TakeToDst(mode, src, dst);
 
            inventoryDebugPrint("[inv] I::Take2Target(" + typename.EnumToString(InventoryMode, mode) + ") target=" + target + " item=" + item + " Warning - no room for item in target");
            return false;
        }
        Error("[inv] I::Take2Target(" + typename.EnumToString(InventoryMode, mode) + ") target=" + target + " item=" + item + " Error - src has no inventory location");
        return false;
    }
 
    bool TakeToDst (InventoryMode mode, notnull InventoryLocation src, notnull InventoryLocation dst)
    {
        bool ret;
        switch (mode)
        {
            case InventoryMode.SERVER:
                ret = LocationSyncMoveEntity(src, dst);
                if (ret && dst.IsValid())
                    InventoryInputUserData.SendServerMove(null, InventoryCommandType.SYNC_MOVE, src, dst);
                return ret;
            case InventoryMode.LOCAL:
                ret = LocationSyncMoveEntity(src, dst);
                //InventoryInputUserData.SendInputUserDataMove(InventoryCommandType.SYNC_MOVE, src, dst);
                //Print(ret);
                return ret;
            default:
                return false;
        }
        return false;
    }
 
    bool TakeEntityToCargo (InventoryMode mode, notnull EntityAI item)
    {
        inventoryDebugPrint("[inv] I::Take2Cgo(" + typename.EnumToString(InventoryMode, mode) + ") item=" + item);
        return TakeEntityToInventory(mode, FindInventoryLocationType.CARGO, item);
    }
 
    bool TakeEntityToTargetCargo (InventoryMode mode, notnull EntityAI target, notnull EntityAI item)
    {
        inventoryDebugPrint("[inv] I::Take2TargetCgo(" + typename.EnumToString(InventoryMode, mode) + ") item=" + item + "to cargo of target=" + target);
        return TakeEntityToTargetInventory(mode, target, FindInventoryLocationType.CARGO, item);
    }
 
    bool TakeEntityToCargoEx (InventoryMode mode, notnull EntityAI item, int idx, int row, int col)
    {
        inventoryDebugPrint("[inv] I::Take2Cgo(" + typename.EnumToString(InventoryMode, mode) + ") item=" + item + " row=" + row + " col=" + col);
        InventoryLocation src = new InventoryLocation;
        if (item.GetInventory().GetCurrentInventoryLocation(src))
        {
            InventoryLocation dst = new InventoryLocation;
            dst.SetCargo(GetInventoryOwner(), item, idx, row, col, item.GetInventory().GetFlipCargo());
 
            return TakeToDst(mode, src, dst);
        }
        Error("[inv] I::Take2Cgo(" + typename.EnumToString(InventoryMode, mode) + ") item=" + item + " row=" + row + " col=" + col + " Error - src has no inventory location");
        return false;
    }
 
    bool TakeEntityToTargetCargoEx (InventoryMode mode, notnull CargoBase cargo, notnull EntityAI item, int row, int col)
    {
        inventoryDebugPrint("[inv] I::Take2TargetCgoEx(" + typename.EnumToString(InventoryMode, mode) + ") item=" + item + "to cargo of target=" + cargo.GetCargoOwner() + " row=" + row + " col=" + col);
        InventoryLocation src = new InventoryLocation;
        if (item.GetInventory().GetCurrentInventoryLocation(src))
        {
            InventoryLocation dst = new InventoryLocation;
            dst.SetCargoAuto(cargo, item, row, col, item.GetInventory().GetFlipCargo());
 
            return TakeToDst(mode, src, dst);
        }
        Error("[inv] I::Take2TargetCgoEx(" + typename.EnumToString(InventoryMode, mode) + ") item=" + item + "to cargo of target=" + cargo.GetCargoOwner() + " row=" + row + " col=" + col);
        return false;
    }
 
    bool TakeEntityAsAttachmentEx (InventoryMode mode, notnull EntityAI item, int slot)
    {
        inventoryDebugPrint("[inv] I::Take2AttEx(" + typename.EnumToString(InventoryMode, mode) + ") item=" + item + " slot=" + slot);
        return TakeEntityAsTargetAttachmentEx(mode, GetInventoryOwner(), item, slot);
    }
 
    bool TakeEntityAsTargetAttachmentEx (InventoryMode mode, notnull EntityAI target, notnull EntityAI item, int slot)
    {
        inventoryDebugPrint("[inv] I::Take2TargetAttEx(" + typename.EnumToString(InventoryMode, mode) + ") as ATT of target=" + target + " item=" + item + " slot=" + slot);
        InventoryLocation src = new InventoryLocation;
        if (item.GetInventory().GetCurrentInventoryLocation(src))
        {
            
            EntityAI att = target.GetInventory().FindAttachment(slot);
            
            if(att)
            {
                att.CombineItemsClient(item, true );
                return true;
            }
            else
            {
                InventoryLocation dst = new InventoryLocation;
                dst.SetAttachment(target, item, slot);
                return TakeToDst(mode, src, dst);
            }
        }
        Error("[inv] I::Take2AttEx(" + typename.EnumToString(InventoryMode, mode) + ") item=" + item + " Error - src has no inventory location");
        return false;
    }
 
    bool TakeEntityAsAttachment (InventoryMode mode, notnull EntityAI item)
    {
        inventoryDebugPrint("[inv] I::Take2Att(" + typename.EnumToString(InventoryMode, mode) + ") item=" + item);
        return TakeEntityToInventory(mode, FindInventoryLocationType.ATTACHMENT, item);
    }
 
    bool TakeEntityAsTargetAttachment (InventoryMode mode, notnull EntityAI target, notnull EntityAI item)
    {
        inventoryDebugPrint("[inv] I::Take2AttEx(" + typename.EnumToString(InventoryMode, mode) + ") item=" + item);
        return TakeEntityToTargetInventory(mode, target, FindInventoryLocationType.ATTACHMENT, item);
    }
 
    static bool MakeDstForSwap (notnull InventoryLocation src1, notnull InventoryLocation src2, out InventoryLocation dst1, out InventoryLocation dst2)
    {
        if (dst1 == null)
            dst1 = new InventoryLocation;
        dst1.Copy(src1);
        dst1.CopyLocationFrom(src2, false);
        dst1.SetFlip(src1.GetItem().GetInventory().GetFlipCargo()); // update flip flag from inventory item
        
        if (dst2 == null)
            dst2 = new InventoryLocation;
        dst2.Copy(src2);
        dst2.CopyLocationFrom(src1, false);
        dst2.SetFlip(src2.GetItem().GetInventory().GetFlipCargo()); // update flip flag from inventory item
        return true;
    }
 
    static bool MakeSrcAndDstForSwap (notnull EntityAI item1, notnull EntityAI item2, out InventoryLocation src1, out InventoryLocation src2, out InventoryLocation dst1, out InventoryLocation dst2)
    {
        if (src1 == null)
            src1 = new InventoryLocation;
        if (src2 == null)
            src2 = new InventoryLocation;
        if (item1.GetInventory().GetCurrentInventoryLocation(src1) && item2.GetInventory().GetCurrentInventoryLocation(src2))
            return MakeDstForSwap(src1, src2, dst1, dst2);
        return false;
    }
 
    static bool MakeSrcAndDstForForceSwap (notnull EntityAI item1, notnull EntityAI item2, out InventoryLocation src1, out InventoryLocation src2, out InventoryLocation dst1, notnull InventoryLocation dst2)
    {
        if (src1 == null)
            src1 = new InventoryLocation;
        if (src2 == null)
            src2 = new InventoryLocation;
        if (item1.GetInventory().GetCurrentInventoryLocation(src1) && item2.GetInventory().GetCurrentInventoryLocation(src2))
        {
            // src1 -> dst_of(src2)
            if (dst1 == null)
                dst1 = new InventoryLocation;
            dst1.Copy(src1);
            dst1.CopyLocationFrom(src2, false);
            dst1.SetFlip(dst1.GetItem().GetInventory().GetFlipCargo());
 
            // src2 -> dst2 from user
            return true;
        }
 
        return false;
    }
 
    bool SwapEntities(InventoryMode mode, notnull EntityAI item1, notnull EntityAI item2)
    {
        return false;
    }
 
    bool ForceSwapEntities(InventoryMode mode, notnull EntityAI item1, notnull EntityAI item2, notnull InventoryLocation item2_dst)
    {
        return false;
    }
 
    static bool SetGroundPosByOwner(EntityAI owner, notnull EntityAI item, out InventoryLocation ground)
    {
        vector m4[4];
        Math3D.MatrixIdentity4(m4);
        bool success = GameInventory.PrepareDropEntityPos(owner, item, m4, false, GameConstants.INVENTORY_ENTITY_DROP_OVERLAP_DEPTH);
        ground.SetGround(item, m4);
        return success;
    }
 
    bool DropEntity(InventoryMode mode, EntityAI owner, notnull EntityAI item)
    {
        inventoryDebugPrint("[inv] I::Drop(" + typename.EnumToString(InventoryMode, mode) + ") item=" + item);
        InventoryLocation src = new InventoryLocation;
        if (item.GetInventory().GetCurrentInventoryLocation(src))
        {
            InventoryLocation dst = new InventoryLocation;
            if (!SetGroundPosByOwner(owner, item, dst))
            {
                OnInventoryFailure(InventoryCommandType.SYNC_MOVE, InventoryValidationReason.DROP_PREVENTED, src, dst);
                return false;
            }
 
            return TakeToDst(mode, src, dst);
        }
 
        Error("DropEntity - No inventory location");
        return false;
    }
    
    static bool SetGroundPosByTransform(EntityAI owner, notnull EntityAI item, out InventoryLocation ground, vector transform[4])
    {
        bool success = GameInventory.PrepareDropEntityPos(owner, item, transform, true, GameConstants.INVENTORY_ENTITY_DROP_OVERLAP_DEPTH);
        ground.SetGround(item, transform);
        return success;
    }
    
    bool DropEntityWithTransform(InventoryMode mode, EntityAI owner, notnull EntityAI item, vector transform[4])
    {
        inventoryDebugPrint("[inv] I::Drop(" + typename.EnumToString(InventoryMode, mode) + ") item=" + item);
        InventoryLocation src = new InventoryLocation();
        if (item.GetInventory().GetCurrentInventoryLocation(src))
        {
            InventoryLocation dst = new InventoryLocation();
            if (!SetGroundPosByTransform(owner, item, dst, transform))
            {
                OnInventoryFailure(InventoryCommandType.SYNC_MOVE, InventoryValidationReason.DROP_PREVENTED, src, dst);
                return false;
            }
 
            return TakeToDst(mode, src, dst);
        }
 
        Error("DropEntityWithTransform - No inventory location");
        return false;
    }
    
    static void SetGroundPosByOwnerBounds(EntityAI owner, notnull EntityAI item, out InventoryLocation ground, vector halfExtents, float angle, float cosAngle, float sinAngle)
    {
        vector m4[4];
        owner.GetTransform(m4);
            
        vector randomPos = Vector(Math.RandomFloat(-halfExtents[0], halfExtents[0]), 0, Math.RandomFloat(-halfExtents[2], halfExtents[2]));
        randomPos = vector.RotateAroundZero(randomPos, vector.Up, cosAngle, sinAngle);
        
        float dist = randomPos[0] * m4[1][0] + randomPos[1] * m4[1][1] + randomPos[2] * m4[1][2];
 
        m4[3][0] = m4[3][0] + randomPos[0];
        m4[3][1] = m4[3][1] - dist + halfExtents[1];
        m4[3][2] = m4[3][2] + randomPos[2];
        
        item.PlaceOnSurfaceRotated(m4, Vector(m4[3][0], m4[3][1], m4[3][2]));
        
        ground.SetGround(item, m4);
    }
    
    bool DropEntityInBounds(InventoryMode mode, EntityAI owner, notnull EntityAI item, vector halfExtents, float angle, float cosAngle, float sinAngle)
    {
        inventoryDebugPrint("[inv] I::Drop(" + typename.EnumToString(InventoryMode, mode) + ") item=" + item);
        
        InventoryLocation src = new InventoryLocation;
        if (item.GetInventory().GetCurrentInventoryLocation(src))
        {
            InventoryLocation dst = new InventoryLocation;  
 
            SetGroundPosByOwnerBounds(owner, item, dst, halfExtents, angle, cosAngle, sinAngle);
 
            return TakeToDst(mode, src, dst);
        }
 
        Error("DropEntityInBounds - No inventory location");
        return false;
    }
 
    bool LocalDestroyEntity(notnull EntityAI item)
    {
        inventoryDebugPrint("[inv] I::LocalDestroyEntity inv item=" + item);
        InventoryLocation src = new InventoryLocation;
        if (item.GetInventory().GetCurrentInventoryLocation(src))
        {
            if (src.GetType() == InventoryLocationType.HANDS)
                Error("[inv] Source location == HANDS, player has to handle this");
 
            GetGame().ObjectDelete(src.GetItem());
            return true;
        }
 
        Error("LocalDestroyEntity: No inventory location");
        return false;
    }
 
    bool ReplaceItemWithNew(InventoryMode mode, ReplaceItemWithNewLambdaBase lambda)
    {
        InventoryLocation src = new InventoryLocation();
        if (lambda.m_OldItem.GetInventory().GetCurrentInventoryLocation(src))
        {
            inventoryDebugPrint("[inv] I::ReplaceItemWithNew executing lambda=" + lambda + "on old_item=" + lambda.m_OldItem);
            lambda.Execute();
            return true;
        }
 
        Error("[inv] I::ReplaceItemWithNew - no inventory location");
        return false;
    }
    
    proto native bool GetFlipCargo();
    proto native void SetFlipCargo(bool flip);
    proto native void FlipCargo();
    proto native void ResetFlipCargo();
};