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);
};