man.c

Go to the documentation of this file.

class Man extends EntityAI
{
    proto native UAInterface GetInputInterface();
    proto native PlayerIdentity GetIdentity();
    proto native EntityAI GetDrivingVehicle();
 
    proto native owned string GetCurrentWeaponMode();
 
    proto native void SetSpeechRestricted(bool state);
    proto native bool IsSpeechRestricted();
 
    proto native void SetFaceTexture(string texture_name);
    proto native void SetFaceMaterial(string material_name);
 
    proto native bool IsSoundInsideBuilding();
    proto native bool IsCameraInsideVehicle();
 
    proto native owned string GetMasterAttenuation();
    proto native void SetMasterAttenuation(string masterAttenuation);
 
    void Man()
    {
        SetFlags(EntityFlags.TOUCHTRIGGERS, false);
    }
 
    override bool IsMan()
    {
        return true;
    }
 
    override bool IsHealthVisible()
    {
        return false;
    }
 
    override bool HasFixedActionTargetCursorPosition()
    {
        return true;
    }
 
    bool IsUnconscious();
 
    int GetPlayerState()
    {
        if (IsAlive())
            return EPlayerStates.ALIVE;
        
        return EPlayerStates.DEAD;
    }
    
    void AddItemToDelete(EntityAI item);
 
    HumanInventory GetHumanInventory()
    {
        HumanInventory i = HumanInventory.Cast(GetInventory());
        return i;
    }
 
    //Called when an item is removed from the cargo of this item
    protected ref ScriptInvoker     m_OnItemAddedToHands;
    //Called when an item is moved around in the cargo of this item
    protected ref ScriptInvoker     m_OnItemRemovedFromHands;
    
    ScriptInvoker GetOnItemAddedToHands()
    {
        if (!m_OnItemAddedToHands)
            m_OnItemAddedToHands = new ScriptInvoker();
        
        return m_OnItemAddedToHands;
    }
    
    
    ScriptInvoker GetOnItemRemovedFromHands()
    {
        if( !m_OnItemRemovedFromHands )
            m_OnItemRemovedFromHands = new ScriptInvoker;
        
        return m_OnItemRemovedFromHands;
    }
    
    void EEItemIntoHands(EntityAI item)
    {
        SetWeightDirty();
        if( m_OnItemAddedToHands )
            m_OnItemAddedToHands.Invoke( item, this );
    }
    
    void EEItemOutOfHands(EntityAI item)
    {
        SetWeightDirty();
        if( m_OnItemRemovedFromHands )
            m_OnItemRemovedFromHands.Invoke( item, this );
    }
 
    bool JunctureDropEntity (notnull EntityAI item)
    {
        return DropEntityImpl(InventoryMode.JUNCTURE, this, item);
    }
 
    override bool PredictiveDropEntity (notnull EntityAI item)
    {
        if (!ScriptInputUserData.CanStoreInputUserData())
        {
            Print("[inv] " + GetSimulationTimeStamp() + " Man@" + this + " ::PredictiveDropEntity input data not sent yet, cannot allow another input action");
            return false;
        }
 
        if (NeedInventoryJunctureFromServer(item, item.GetHierarchyParent(), this))
            return JunctureDropEntity(item);
        else
            return DropEntityImpl(InventoryMode.PREDICTIVE, this, item);
    }
 
    override bool LocalDropEntity (notnull EntityAI item)
    {
        return DropEntityImpl(InventoryMode.LOCAL, this, item);
    }
 
    override bool ServerDropEntity (notnull EntityAI item)
    {
        return DropEntityImpl(InventoryMode.SERVER, this, item);
    }
 
    protected bool DropEntityImpl (InventoryMode mode, notnull EntityAI owner, notnull EntityAI item)
    {
        if (LogManager.IsSyncLogEnable()) syncDebugPrint("[inv] " + GetDebugName(this) + " STS = " + GetSimulationTimeStamp() + " ::DropEntity(" + typename.EnumToString(InventoryMode, mode) + ") item=" + Object.GetDebugName(item));
        bool code = GetHumanInventory().DropEntity(mode, owner, item);
        UpdateInventoryMenu();
        return code;
    }
 
    override bool CanDropEntity (notnull EntityAI item) { return true; }
 
    void OnItemInHandsChanged () { }
 
    bool NeedInventoryJunctureFromServer (notnull EntityAI item, EntityAI currParent, EntityAI newParent) { return false; }
 
    void JunctureTakeEntityToHands (notnull EntityAI item)
    {
        TakeEntityToHandsImpl(InventoryMode.JUNCTURE, item);
    }
 
    void PredictiveTakeEntityToHands (EntityAI item)
    {
        if (!ScriptInputUserData.CanStoreInputUserData())
        {
            Print("[inv] " + GetSimulationTimeStamp() + " Man@" + this + " ::PredictiveTakeEntityToHands input data not sent yet, cannot allow another input action");
            return;
        }
 
        if (NeedInventoryJunctureFromServer(item, item.GetHierarchyParent(), this))
            JunctureTakeEntityToHands(item);
        else
            TakeEntityToHandsImpl(InventoryMode.PREDICTIVE, item);
    }
 
    void LocalTakeEntityToHands (EntityAI item)
    {
        TakeEntityToHandsImpl(InventoryMode.LOCAL, item);
    }
    
    void ServerTakeEntityToHands (EntityAI item)
    {
        TakeEntityToHandsImpl(InventoryMode.SERVER, item);
    }
 
    void TakeEntityToHandsImpl (InventoryMode mode, EntityAI item)
    {
        if (!GetGame().IsDedicatedServer() )
        {
            InventoryLocation il = new InventoryLocation;
            il.SetHands(this, item);
            //GetInventory().AddInventoryReservationEx(item, il ,GameInventory.c_InventoryReservationTimeoutShortMS);
        }
            
        if (LogManager.IsSyncLogEnable()) syncDebugPrint("[inv] " + GetDebugName(this) + " STS = " + GetSimulationTimeStamp() + " ::Take2Hands(" + typename.EnumToString(InventoryMode, mode) + ") item=" + Object.GetDebugName(item));
        EntityAI itemInHands = GetHumanInventory().GetEntityInHands();
        
        InventoryLocation src_item = new InventoryLocation;
        if (item.GetInventory().GetCurrentInventoryLocation(src_item))
        {
            if (itemInHands == null)
            {   
                InventoryLocation hand_dst = new InventoryLocation;
                hand_dst.SetHands(this, item);
                GetHumanInventory().TakeToDst(mode, src_item, hand_dst);
            }
            else if (GetHumanInventory().CanSwapEntitiesEx(itemInHands, item))
                GetInventory().SwapEntities(mode, itemInHands, item);
            UpdateInventoryMenu();
        }
    }
 
    void LocalDestroyEntityInHands ()
    {
        if (LogManager.IsSyncLogEnable()) syncDebugPrint("[inv] " + GetDebugName(this) + " STS = " + GetSimulationTimeStamp() + " Destroy IH=" + GetHumanInventory().GetEntityInHands());
        GetHumanInventory().LocalDestroyEntity(GetHumanInventory().GetEntityInHands());
        UpdateInventoryMenu();
    }
 
    void PredictiveMoveItemFromHandsToInventory ()
    {
        if (LogManager.IsSyncLogEnable()) syncDebugPrint("[inv] " + GetDebugName(this) + " STS = " + GetSimulationTimeStamp() + " Stash IH=" + GetHumanInventory().GetEntityInHands());
        if (!ScriptInputUserData.CanStoreInputUserData())
        {
            Print("[inv] PredictiveMoveItemFromHandsToInventory input data not sent yet, cannot allow another input action");
            return;
        }
        
        InventoryMode invMode = InventoryMode.PREDICTIVE;
        
        if (NeedInventoryJunctureFromServer( GetHumanInventory().GetEntityInHands(), this, this))
            invMode = InventoryMode.JUNCTURE;
 
        if (GetHumanInventory().GetEntityInHands().m_OldLocation && GetHumanInventory().GetEntityInHands().m_OldLocation.IsValid())
        {
            InventoryLocation invLoc = new InventoryLocation;
            GetHumanInventory().GetEntityInHands().GetInventory().GetCurrentInventoryLocation(invLoc);
            //old location is somewhere on player
            if (GetHumanInventory().GetEntityInHands().m_OldLocation.GetParent() && GetHumanInventory().GetEntityInHands().m_OldLocation.GetParent().GetHierarchyRootPlayer())
            {
                if (GetHumanInventory().LocationCanMoveEntity(invLoc, GetHumanInventory().GetEntityInHands().m_OldLocation))
                {
                    if (GetHumanInventory().TakeToDst(invMode, invLoc,GetHumanInventory().GetEntityInHands().m_OldLocation))
                    {
                        UpdateInventoryMenu();
                        return;
                    }
                }
            }
        }
 
        GetHumanInventory().TakeEntityToInventory(invMode, FindInventoryLocationType.ATTACHMENT | FindInventoryLocationType.CARGO, GetHumanInventory().GetEntityInHands());     
        UpdateInventoryMenu();
    }
 
    protected bool ReplaceItemWithNewImpl(InventoryMode mode, ReplaceItemWithNewLambdaBase lambda)
    {
        if (LogManager.IsSyncLogEnable()) syncDebugPrint("[inv] " + GetDebugName(this) + " STS = " + GetSimulationTimeStamp() + " Replace !HND lambda=" + lambda.DumpToString());
        bool code = GetHumanInventory().ReplaceItemWithNew(mode, lambda);
        UpdateInventoryMenu();
        return code;
    }
 
    bool LocalReplaceItemWithNew(ReplaceItemWithNewLambdaBase lambda)
    {
        return ReplaceItemWithNewImpl(InventoryMode.LOCAL, lambda);
    }
 
    bool ServerReplaceItemWithNew(ReplaceItemWithNewLambdaBase lambda)
    {
        return ReplaceItemWithNewImpl(InventoryMode.SERVER, lambda);
    }
    
    protected bool ReplaceItemElsewhereWithNewInHandsImpl (InventoryMode mode, ReplaceItemWithNewLambdaBase lambda)
    {
        if (LogManager.IsSyncLogEnable()) syncDebugPrint("[inv] " + GetDebugName(this) + " STS = " + GetSimulationTimeStamp() + " Replace !HND->HND lambda=" + lambda.DumpToString());
        bool code = GetHumanInventory().ReplaceItemElsewhereWithNewInHands(mode, lambda);
        UpdateInventoryMenu();
        return code;
    }
 
    bool LocalReplaceItemElsewhereWithNewInHands (ReplaceItemWithNewLambdaBase lambda)
    {
        return ReplaceItemElsewhereWithNewInHandsImpl(InventoryMode.LOCAL, lambda);
    }
 
    bool ServerReplaceItemElsewhereWithNewInHands (ReplaceItemWithNewLambdaBase lambda)
    {
        return ReplaceItemElsewhereWithNewInHandsImpl(InventoryMode.SERVER, lambda);
    }
 
    protected bool ReplaceItemInHandsWithNewImpl (InventoryMode mode, ReplaceItemWithNewLambdaBase lambda)
    {
        if (LogManager.IsSyncLogEnable()) syncDebugPrint("[inv] " + GetDebugName(this) + " STS = " + GetSimulationTimeStamp() + " Replace HND->HND lambda=" + lambda.DumpToString());
        bool code = GetHumanInventory().ReplaceItemInHandsWithNew(mode, lambda);
        UpdateInventoryMenu();
        return code;
    }
 
    bool LocalReplaceItemInHandsWithNew (ReplaceItemWithNewLambdaBase lambda)
    {
        return ReplaceItemInHandsWithNewImpl(InventoryMode.LOCAL, lambda);
    }
 
    bool ServerReplaceItemInHandsWithNew (ReplaceItemWithNewLambdaBase lambda)
    {
        return ReplaceItemInHandsWithNewImpl(InventoryMode.SERVER, lambda);
    }
    
    protected bool ReplaceItemInHandsWithNewElsewhereImpl (InventoryMode mode, ReplaceItemWithNewLambdaBase lambda)
    {
        if (LogManager.IsSyncLogEnable()) syncDebugPrint("[inv] " + GetDebugName(this) + " STS = " + GetSimulationTimeStamp() + " Replace HND->elsewhere lambda=" + lambda.DumpToString());
        bool code = GetHumanInventory().ReplaceItemInHandsWithNewElsewhere(mode, lambda);
        UpdateInventoryMenu();
        return code;
    }
    
    bool LocalReplaceItemInHandsWithNewElsewhere (ReplaceItemWithNewLambdaBase lambda)
    {
        return ReplaceItemInHandsWithNewElsewhereImpl(InventoryMode.LOCAL, lambda);
    }
    
    bool ServerReplaceItemInHandsWithNewElsewhere (ReplaceItemWithNewLambdaBase lambda)
    {
        return ReplaceItemInHandsWithNewElsewhereImpl(InventoryMode.SERVER, lambda);
    }
 
    bool JunctureTakeEntityToInventory (FindInventoryLocationType flags, notnull EntityAI item)
    {
        return TakeEntityToInventoryImpl(InventoryMode.JUNCTURE, flags, item);
    }
 
    override bool PredictiveTakeEntityToInventory (FindInventoryLocationType flags, notnull EntityAI item)
    {
        if (!ScriptInputUserData.CanStoreInputUserData())
        {
            Print("[inv] " + GetSimulationTimeStamp() + " Man@" + this + " ::PredictiveTakeEntityToInventory input data not sent yet, cannot allow another input action");
            return false;
        }
 
        if (NeedInventoryJunctureFromServer(item, item.GetHierarchyParent(), this))
            return JunctureTakeEntityToInventory(flags, item);
        else
            return TakeEntityToInventoryImpl(InventoryMode.PREDICTIVE, flags, item);
    }
 
    override bool LocalTakeEntityToInventory (FindInventoryLocationType flags, notnull EntityAI item)
    {
        return TakeEntityToInventoryImpl(InventoryMode.LOCAL, flags, item);
    }
 
    override bool ServerTakeEntityToInventory (FindInventoryLocationType flags, notnull EntityAI item)
    {
        return TakeEntityToInventoryImpl(InventoryMode.SERVER, flags, item);
    }
 
    protected bool TakeEntityToInventoryImpl (InventoryMode mode, FindInventoryLocationType flags, notnull EntityAI item)
    {
        if (LogManager.IsSyncLogEnable()) syncDebugPrint("[inv] " + GetDebugName(this) + " STS = " + GetSimulationTimeStamp() + " ::Take2Inv(" + typename.EnumToString(InventoryMode, mode) + ") item=" + Object.GetDebugName(item));
        bool code = GetHumanInventory().TakeEntityToInventory(mode, flags, item);
        UpdateInventoryMenu();
        return code;
    }
 
    bool JunctureTakeEntityToCargo (notnull EntityAI item)
    {
        return TakeEntityToCargoImpl(InventoryMode.JUNCTURE, item);
    }
 
    override bool PredictiveTakeEntityToCargo (notnull EntityAI item)
    {
        if (!ScriptInputUserData.CanStoreInputUserData())
        {
            Print("[inv] " + GetSimulationTimeStamp() + " Man@" + this + " ::PredictiveTakeEntityToCargo input data not sent yet, cannot allow another input action");
            return false;
        }
 
        if (NeedInventoryJunctureFromServer(item, item.GetHierarchyParent(), this))
            return JunctureTakeEntityToCargo(item);
        else
            return TakeEntityToCargoImpl(InventoryMode.PREDICTIVE, item);
    }
 
    override bool LocalTakeEntityToCargo (notnull EntityAI item)
    {
        return TakeEntityToCargoImpl(InventoryMode.LOCAL, item);
    }
 
    override bool ServerTakeEntityToCargo (notnull EntityAI item)
    {
        return TakeEntityToCargoImpl(InventoryMode.SERVER, item);
    }
 
    protected bool TakeEntityToCargoImpl (InventoryMode mode, notnull EntityAI item)
    {
        if (LogManager.IsSyncLogEnable()) syncDebugPrint("[inv] " + GetDebugName(this) + " STS = " + GetSimulationTimeStamp() + " ::Take2Cgo(" + typename.EnumToString(InventoryMode, mode) + ") item=" + Object.GetDebugName(item));
        bool code = GetHumanInventory().TakeEntityToCargo(mode, item);
        UpdateInventoryMenu();
        return code;
    }
 
    bool JunctureTakeEntityAsAttachment (notnull EntityAI item)
    {
        return TakeEntityAsAttachmentImpl(InventoryMode.JUNCTURE, item);
    }
 
    override bool PredictiveTakeEntityAsAttachment (notnull EntityAI item)
    {
        if (!ScriptInputUserData.CanStoreInputUserData())
        {
            Print("[inv] " + GetSimulationTimeStamp() + " Man@" + this + " ::PredictiveTakeEntityAsAttachment input data not sent yet, cannot allow another input action");
            return false;
        }
 
        if (NeedInventoryJunctureFromServer(item, item.GetHierarchyParent(), this))
            return JunctureTakeEntityAsAttachment(item);
        else
            return TakeEntityAsAttachmentImpl(InventoryMode.PREDICTIVE, item);
    }
 
    override bool LocalTakeEntityAsAttachment (notnull EntityAI item)
    {
        return TakeEntityAsAttachmentImpl(InventoryMode.LOCAL, item);
    }
 
    override bool ServerTakeEntityAsAttachment (notnull EntityAI item)
    {
        return TakeEntityAsAttachmentImpl(InventoryMode.SERVER, item);
    }
 
    protected bool TakeEntityAsAttachmentImpl (InventoryMode mode, notnull EntityAI item)
    {
        if (LogManager.IsSyncLogEnable()) syncDebugPrint("[inv] " + GetDebugName(this) + " STS = " + GetSimulationTimeStamp() + " ::Take2Att(" + typename.EnumToString(InventoryMode, mode) + ") item=" + Object.GetDebugName(item));
        bool code = GetHumanInventory().TakeEntityAsAttachment(mode, item);
        UpdateInventoryMenu();
        return code;
    }
 
    bool JunctureTakeEntityAsAttachmentEx (notnull EntityAI item, int slot)
    {
        return TakeEntityAsAttachmentExImpl(InventoryMode.JUNCTURE, item, slot);
    }
 
    override bool PredictiveTakeEntityAsAttachmentEx (notnull EntityAI item, int slot)
    {
        if (!ScriptInputUserData.CanStoreInputUserData())
        {
            Print("[inv] " + GetSimulationTimeStamp() + " Man@" + this + " ::PredictiveTakeEntityAsAttachmentEx input data not sent yet, cannot allow another input action");
            return false;
        }
 
        if (NeedInventoryJunctureFromServer(item, item.GetHierarchyParent(), this))
            return JunctureTakeEntityAsAttachmentEx(item, slot);
        else
            return TakeEntityAsAttachmentExImpl(InventoryMode.PREDICTIVE, item, slot);
    }
 
    override bool LocalTakeEntityAsAttachmentEx (notnull EntityAI item, int slot)
    {
        return TakeEntityAsAttachmentExImpl(InventoryMode.LOCAL, item, slot);
    }
 
    override bool ServerTakeEntityAsAttachmentEx (notnull EntityAI item, int slot)
    {
        return TakeEntityAsAttachmentExImpl(InventoryMode.SERVER, item, slot);
    }
 
    protected bool TakeEntityAsAttachmentExImpl (InventoryMode mode, notnull EntityAI item, int slot)
    {
        if (LogManager.IsSyncLogEnable()) syncDebugPrint("[inv] " + GetDebugName(this) + " STS = " + GetSimulationTimeStamp() + " ::Take2AttEx(" + typename.EnumToString(InventoryMode, mode) + ") item=" + Object.GetDebugName(item));
        bool code = GetHumanInventory().TakeEntityAsAttachmentEx(mode, item, slot);
        UpdateInventoryMenu();
        return code;
    }
 
    bool JunctureSwapEntities (notnull EntityAI item1, notnull EntityAI item2)
    {
        return SwapEntitiesImpl(InventoryMode.JUNCTURE, item1, item2);
    }
 
    bool PredictiveSwapEntities (notnull EntityAI item1, notnull EntityAI item2)
    {
        if (!ScriptInputUserData.CanStoreInputUserData())
        {
            Print("[inv] " + GetSimulationTimeStamp() + " Man@" + this + " ::PredictiveSwapEntities input data not sent yet, cannot allow another input action");
            return false;
        }
 
        bool need_j1 = NeedInventoryJunctureFromServer(item1, item1.GetHierarchyParent(), item2.GetHierarchyParent());
        bool need_j2 = NeedInventoryJunctureFromServer(item2, item2.GetHierarchyParent(), item1.GetHierarchyParent());
        if (need_j1 || need_j2)
            return SwapEntitiesImpl(InventoryMode.JUNCTURE, item1, item2);
        else
            return SwapEntitiesImpl(InventoryMode.PREDICTIVE, item1, item2);
    }
 
    bool LocalSwapEntities (notnull EntityAI item1, notnull EntityAI item2)
    {
        return SwapEntitiesImpl(InventoryMode.LOCAL, item1, item2);
    }
 
    bool ServerSwapEntities (notnull EntityAI item1, notnull EntityAI item2)
    {
        return SwapEntitiesImpl(InventoryMode.SERVER, item1, item2);
    }
 
    protected bool SwapEntitiesImpl (InventoryMode mode, notnull EntityAI item1, notnull EntityAI item2)
    {
        bool code;
        if (LogManager.IsSyncLogEnable()) syncDebugPrint("[inv] " + GetDebugName(this) + " STS = " + GetSimulationTimeStamp() + " ::SwapImpl(" + typename.EnumToString(InventoryMode, mode) + ") item1=" + Object.GetDebugName(item1) + " item2=" + item2.GetDebugName(this));
        if (!GameInventory.CanSwapEntitiesEx(item1, item2))
            Error("[inv] (Man@" + this + ") SwapEntitiesImpl - cannot swap items!");
 
        code = GetHumanInventory().SwapEntities(mode, item1, item2);
 
        UpdateInventoryMenu();
        if (!code)
            if (LogManager.IsSyncLogEnable()) syncDebugPrint("[inv] " + GetDebugName(this) + " STS = " + GetSimulationTimeStamp() + "  SwapEntitiesImpl - cannot swap or forceswap");
        return code;
    }
 
    bool JunctureForceSwapEntities (notnull EntityAI item1, notnull EntityAI item2, notnull InventoryLocation item2_dst)
    {
        return ForceSwapEntitiesImpl(InventoryMode.JUNCTURE, item1, item2, item2_dst);
    }
 
    bool PredictiveForceSwapEntities (notnull EntityAI item1, notnull EntityAI item2, notnull InventoryLocation item2_dst)
    {
        if (!ScriptInputUserData.CanStoreInputUserData())
        {
            Print("[inv] " + GetSimulationTimeStamp() + " Man@" + this + " ::PredictiveForceSwapEntities input data not sent yet, cannot allow another input action");
            return false;
        }
 
        bool need_j1 = NeedInventoryJunctureFromServer(item1, item1.GetHierarchyParent(), item2.GetHierarchyParent());
        bool need_j2 = NeedInventoryJunctureFromServer(item2, item2.GetHierarchyParent(), item1.GetHierarchyParent());
        if (need_j1 || need_j2)
            return ForceSwapEntitiesImpl(InventoryMode.JUNCTURE, item1, item2, item2_dst);
        else
            return ForceSwapEntitiesImpl(InventoryMode.PREDICTIVE, item1, item2, item2_dst);
    }
 
    bool LocalForceSwapEntities (notnull EntityAI item1, notnull EntityAI item2, notnull InventoryLocation item2_dst)
    {
        return ForceSwapEntitiesImpl(InventoryMode.LOCAL, item1, item2, item2_dst);
    }
 
    bool ServerForceSwapEntities (notnull EntityAI item1, notnull EntityAI item2, notnull InventoryLocation item2_dst)
    {
        return ForceSwapEntitiesImpl(InventoryMode.SERVER, item1, item2, item2_dst);
    }
 
    protected bool ForceSwapEntitiesImpl (InventoryMode mode, notnull EntityAI item1, notnull EntityAI item2, notnull InventoryLocation item2_dst)
    {
        bool code = false;
        if (LogManager.IsSyncLogEnable()) syncDebugPrint("[inv] " + GetDebugName(this) + " STS = " + GetSimulationTimeStamp() + "  ForceSwapImpl(" + typename.EnumToString(InventoryMode, mode) + ") item1=" + Object.GetDebugName(item1) + " item2=" + item2.GetDebugName(this));
        code = GetHumanInventory().ForceSwapEntities(mode, item1, item2, item2_dst);
 
        UpdateInventoryMenu();
        if (!code)
            if (LogManager.IsSyncLogEnable()) syncDebugPrint("[inv] " + GetDebugName(this) + " STS = " + GetSimulationTimeStamp() + "  ForceSwapEntitiesImpl - cannot Forceswap");
        return code;
    }
 
    bool JunctureTakeEntityToTargetInventory (notnull EntityAI target, FindInventoryLocationType flags, notnull EntityAI item)
    {
        return TakeEntityToTargetInventoryImpl(InventoryMode.JUNCTURE, target, flags, item);
    }
 
    override bool PredictiveTakeEntityToTargetInventory (notnull EntityAI target, FindInventoryLocationType flags, notnull EntityAI item)
    {
        if (!ScriptInputUserData.CanStoreInputUserData())
        {
            Print("[inv] " + GetSimulationTimeStamp() + " ::PredictiveTakeEntityToTargetInventory input data not sent yet, cannot allow another input action");
            return false;
        }
 
        if (NeedInventoryJunctureFromServer(item, item.GetHierarchyParent(), target))
            return JunctureTakeEntityToTargetInventory(target, flags, item);
        else
            return TakeEntityToTargetInventoryImpl(InventoryMode.PREDICTIVE, target, flags, item);
    }
    
    bool PredictiveTakeOrSwapAttachment( notnull EntityAI item )
    {
        if( GetInventory().CanAddAttachment( item ) )
        {
            return PredictiveTakeEntityAsAttachment( item );
        }
        else
        {
            for( int i = 0; i < item.GetInventory().GetSlotIdCount(); i++ )
            {
                int slot_id = item.GetInventory().GetSlotId(i);
                EntityAI slot_item = GetInventory().FindAttachment( slot_id );
                if( slot_item && GetInventory().CanSwapEntitiesEx( item, slot_item ) )
                {
                    return PredictiveSwapEntities(item, slot_item);
                }
            }
        }
        return false;
    }
 
    override bool LocalTakeEntityToTargetInventory (notnull EntityAI target, FindInventoryLocationType flags, notnull EntityAI item)
    {
        return TakeEntityToTargetInventoryImpl(InventoryMode.LOCAL, target, flags, item);
    }
 
    protected bool TakeEntityToTargetInventoryImpl (InventoryMode mode, notnull EntityAI target, FindInventoryLocationType flags, notnull EntityAI item)
    {
        if (LogManager.IsSyncLogEnable()) syncDebugPrint("[inv] " + GetDebugName(this) + " STS = " + GetSimulationTimeStamp() + " ::Take2TargetInv(" + typename.EnumToString(InventoryMode, mode) + ") item=" + Object.GetDebugName(item));
        bool code = GetInventory().TakeEntityToTargetInventory(mode, target, flags, item);
        UpdateInventoryMenu();
        return code;
    }
 
    bool JunctureTakeEntityToTargetCargoEx (notnull CargoBase cargo, notnull EntityAI item, int row, int col)
    {
        return TakeEntityToTargetCargoExImpl(InventoryMode.JUNCTURE, cargo, item, row, col);
    }
 
    override bool PredictiveTakeEntityToTargetCargoEx (notnull CargoBase cargo, notnull EntityAI item, int row, int col)
    {
        if (!ScriptInputUserData.CanStoreInputUserData())
        {
            Print("[inv] " + GetDebugName(this) + " STS = " + GetSimulationTimeStamp() + " ::PredictiveTakeEntityToTargetCargoEx input data not sent yet, cannot allow another input action");
            return false;
        }
 
        if (NeedInventoryJunctureFromServer(item, item.GetHierarchyParent(), cargo.GetCargoOwner()))
            return JunctureTakeEntityToTargetCargoEx(cargo, item, row, col);
        else
            return TakeEntityToTargetCargoExImpl(InventoryMode.PREDICTIVE, cargo, item, row, col);
    }
 
    override bool LocalTakeEntityToTargetCargoEx (notnull CargoBase cargo, notnull EntityAI item, int row, int col)
    {
        return TakeEntityToTargetCargoExImpl(InventoryMode.LOCAL, cargo, item, row, col);
    }
    
    override bool ServerTakeEntityToTargetCargoEx (notnull CargoBase cargo, notnull EntityAI item, int row, int col)
    {
        return TakeEntityToTargetCargoExImpl(InventoryMode.SERVER, cargo, item, row, col);
    }
 
    protected bool TakeEntityToTargetCargoExImpl (InventoryMode mode, notnull CargoBase cargo, notnull EntityAI item, int row, int col)
    {
        if (LogManager.IsSyncLogEnable()) syncDebugPrint("[inv] " + GetDebugName(this) + " STS = " + GetSimulationTimeStamp() + " ::Take2TargetCgoEx(" + typename.EnumToString(InventoryMode, mode) + ") item=" + Object.GetDebugName(item));
        bool code = GetInventory().TakeEntityToTargetCargoEx(mode, cargo, item, row, col);
        UpdateInventoryMenu();
        return code;
    }
 
    bool JunctureTakeEntityToTargetCargo (notnull EntityAI target, notnull EntityAI item)
    {
        return TakeEntityToTargetCargoImpl(InventoryMode.JUNCTURE, target, item);
    }
 
    override bool PredictiveTakeEntityToTargetCargo (notnull EntityAI target, notnull EntityAI item)
    {
        if (!ScriptInputUserData.CanStoreInputUserData())
        {
            Print("[inv] " + GetDebugName(this) + " STS = " + GetSimulationTimeStamp() + " ::PredictiveTakeEntityToTargetCargo input data not sent yet, cannot allow another input action");
            return false;
        }
 
        if (NeedInventoryJunctureFromServer(item, item.GetHierarchyParent(), target))
            return JunctureTakeEntityToTargetCargo(target, item);
        else
            return TakeEntityToTargetCargoImpl(InventoryMode.PREDICTIVE, target, item);
    }
 
    override bool LocalTakeEntityToTargetCargo (notnull EntityAI target, notnull EntityAI item)
    {
        return TakeEntityToTargetCargoImpl(InventoryMode.LOCAL, target, item);
    }
    
    override bool ServerTakeEntityToTargetCargo (notnull EntityAI target, notnull EntityAI item)
    {
        if (IsAlive())
            return TakeEntityToTargetCargoImpl(InventoryMode.SERVER, target, item);
        else
            return TakeEntityToTargetCargoImpl(InventoryMode.SERVER, target, item);
    }
 
    protected bool TakeEntityToTargetCargoImpl (InventoryMode mode, notnull EntityAI target, notnull EntityAI item)
    {
        if (LogManager.IsSyncLogEnable()) syncDebugPrint("[inv] " + GetDebugName(this) + " STS = " + GetSimulationTimeStamp() + " Take2TargetCgo(" + typename.EnumToString(InventoryMode, mode) + ") item=" + Object.GetDebugName(item));
 
        bool code = GetInventory().TakeEntityToTargetInventory(mode, target, FindInventoryLocationType.CARGO, item);
        UpdateInventoryMenu();
        return code;
    }
 
    bool JunctureTakeEntityToTargetAttachmentEx (notnull EntityAI target, notnull EntityAI item, int slot)
    {
        return TakeEntityToTargetAttachmentExImpl(InventoryMode.JUNCTURE, target, item, slot);
    }
 
    override bool PredictiveTakeEntityToTargetAttachmentEx (notnull EntityAI target, notnull EntityAI item, int slot)
    {
        if (!ScriptInputUserData.CanStoreInputUserData())
        {
            Print("[inv] " + GetDebugName(this) + " STS = " + GetSimulationTimeStamp() + " ::PredictiveTakeEntityToTargetAttachmentEx input data not sent yet, cannot allow another input action");
            return false;
        }
 
        if (NeedInventoryJunctureFromServer(item, item.GetHierarchyParent(), target))
            return JunctureTakeEntityToTargetAttachmentEx(target, item, slot);
        else
            return TakeEntityToTargetAttachmentExImpl(InventoryMode.PREDICTIVE, target, item, slot);
    }
 
    override bool LocalTakeEntityToTargetAttachmentEx (notnull EntityAI target, notnull EntityAI item, int slot)
    {
        return TakeEntityToTargetAttachmentExImpl(InventoryMode.LOCAL, target, item, slot);
    }
 
    override bool ServerTakeEntityToTargetAttachmentEx (notnull EntityAI target, notnull EntityAI item, int slot)
    {
        return TakeEntityToTargetAttachmentExImpl(InventoryMode.SERVER, target, item, slot);
    }
 
    protected bool TakeEntityToTargetAttachmentExImpl (InventoryMode mode, notnull EntityAI target, notnull EntityAI item, int slot)
    {
        if (LogManager.IsSyncLogEnable()) syncDebugPrint("[inv] " + GetDebugName(this) + " STS = " + GetSimulationTimeStamp() + " ::Take2TargetAtt(" + typename.EnumToString(InventoryMode, mode) + ") item=" + Object.GetDebugName(item));
        bool code = GetInventory().TakeEntityAsTargetAttachmentEx(mode, target, item, slot);
        UpdateInventoryMenu();
        return code;
    }
 
    bool JunctureTakeEntityToTargetAttachment (notnull EntityAI target, notnull EntityAI item)
    {
        return TakeEntityToTargetAttachmentImpl(InventoryMode.JUNCTURE, target, item);
    }
 
    override bool PredictiveTakeEntityToTargetAttachment (notnull EntityAI target, notnull EntityAI item)
    {
        if (!ScriptInputUserData.CanStoreInputUserData())
        {
            Print("[inv] " + GetSimulationTimeStamp() + " Man@" + this + " ::PredictiveTakeEntityToTargetAttachment input data not sent yet, cannot allow another input action");
            return false;
        }
 
        if (NeedInventoryJunctureFromServer(item, item.GetHierarchyParent(), target))
            return JunctureTakeEntityToTargetAttachment(target, item);
        else
            return TakeEntityToTargetAttachmentImpl(InventoryMode.PREDICTIVE, target, item);
    }
 
    override bool LocalTakeEntityToTargetAttachment (notnull EntityAI target, notnull EntityAI item)
    {
        return TakeEntityToTargetAttachmentImpl(InventoryMode.LOCAL, target, item);
    }
 
    override bool ServerTakeEntityToTargetAttachment (notnull EntityAI target, notnull EntityAI item)
    {
        return TakeEntityToTargetAttachmentImpl(InventoryMode.SERVER, target, item);
    }
 
    protected bool TakeEntityToTargetAttachmentImpl (InventoryMode mode, notnull EntityAI target, notnull EntityAI item)
    {
        InventoryLocation il = new InventoryLocation;
        if( target.GetInventory().FindFreeLocationFor( item, FindInventoryLocationType.ATTACHMENT, il) )
        {
            return TakeEntityToTargetAttachmentExImpl(mode, target, item, il.GetSlot());
        }
        return false;
    }
 
    bool JunctureTakeToDst (notnull InventoryLocation src, notnull InventoryLocation dst)
    {
        return TakeToDstImpl(InventoryMode.JUNCTURE, src, dst);
    }
 
    override bool PredictiveTakeToDst (notnull InventoryLocation src, notnull InventoryLocation dst)
    {
        if (!ScriptInputUserData.CanStoreInputUserData())
        {
            Print("[inv] " + GetSimulationTimeStamp() + " Man@" + this + " ::PredictiveTakeToDst input data not sent yet, cannot allow another input action");
            return false;
        }
 
        if (NeedInventoryJunctureFromServer(src.GetItem(), src.GetParent(), dst.GetParent()))
            return JunctureTakeToDst(src, dst);
        else
            return TakeToDstImpl(InventoryMode.PREDICTIVE, src, dst);
    }
 
    override bool LocalTakeToDst (notnull InventoryLocation src, notnull InventoryLocation dst)
    {
        return TakeToDstImpl(InventoryMode.LOCAL, src, dst);
    }
 
    override bool ServerTakeToDst (notnull InventoryLocation src, notnull InventoryLocation dst)
    {
        return TakeToDstImpl(InventoryMode.SERVER, src, dst);
    }
 
    protected bool TakeToDstImpl (InventoryMode mode, notnull InventoryLocation src, notnull InventoryLocation dst)
    {
        if (LogManager.IsSyncLogEnable()) syncDebugPrint("[inv] " + GetDebugName(this) + " STS = " + GetSimulationTimeStamp() + " ::Take2Dst(" + typename.EnumToString(InventoryMode, mode) + ") src=" + InventoryLocation.DumpToStringNullSafe(src) + " dst=" + InventoryLocation.DumpToStringNullSafe(dst));
        bool code = GetHumanInventory().TakeToDst(mode, src, dst);
        UpdateInventoryMenu();
        return code;
    }
    
    void JunctureDeleteItem(EntityAI item)
    {
        
    } 
 
    override bool CanBeSkinned()
    {
        return true;
    }
    
    void UpdateInventoryMenu();
    
 
    proto native bool StatRegister( string name );
 
    proto native float StatGet( string name );
 
    proto void StatGetCounter( string name, out string value );
 
    proto void StatGetAsTime( string name, out string value );
 
    proto native void StatUpdate( string name, float value );
 
    proto native void StatUpdateByTime( string name );
 
    proto native void StatUpdateByPosition( string name );
 
    proto native void StatUpdateByGivenPos( string name, vector pos );
    proto native void StatInvokeUpdate();
    proto native void StatSyncToClient();
    
    bool IsInventorySoftLocked()
    {
        return false;
    }
 
    void SetInventorySoftLock(bool status);
    
    bool IsInTransport()
    {
        return Transport.Cast(GetParent()) != null;
    }
    
    void StopDeathDarkeningEffect();
    bool PhysicalPredictiveDropItem(EntityAI entity, bool heavy_item_only = true);
    void SetProcessUIWarning(bool state);
    void OnGameplayDataHandlerSync(); //depricated, sync now happens before the player is created, calling of this event still happens for legacy reasons
    bool CanPlaceItem(EntityAI item);
};