inventory.c

Go to the documentation of this file.

#ifdef PLATFORM_CONSOLE
enum ConsoleActionToolbarMask
{
 EMPTY = 0,
 TO_HANDS_SWAP_VICINITY = 1,
 TO_HANDS_SWAP_INVENTORY = 2,
 DROP = 4,
 EQUIP = 8,
 SPLIT = 16,
 TO_INVENTORY = 32,
 OPEN_CLOSE_CONTAINER = 64,
 MICROMANAGMENT = 128,
 QUICKSLOT = 256,
 COMBINE = 512,
}
#endif
 
enum Direction
{
 RIGHT,
 LEFT,
 UP,
 DOWN
}
 
class Inventory: LayoutHolder
{
 protected ref LeftArea m_LeftArea;
 protected ref RightArea m_RightArea;
 protected ref HandsArea m_HandsArea;
 protected ref PlayerPreview m_PlayerPreview;
 protected ref InventoryQuickbar m_Quickbar;
 
 protected Widget m_QuickbarWidget;
 protected Widget m_SpecializationPanel;
 protected Widget m_SpecializationIcon;
 protected Widget m_TopConsoleToolbarVicinity;
 protected Widget m_TopConsoleToolbarHands;
 protected Widget m_TopConsoleToolbarEquipment;
 protected Widget m_BottomConsoleToolbar;
 protected RichTextWidget m_BottomConsoleToolbarRichText;
 
 protected ref ContextMenu m_ContextMenu;
 protected static ref map<string, int> m_PlayerAttachmentsIndexes;
 
 protected bool m_HadFastTransferred;
 protected bool m_HadInspected;
 protected bool m_NeedUpdateConsoleToolbar;
 
 protected static Inventory m_Instance;
 
 protected int m_ControllerAngle;
 protected int m_ControllerTilt;
 protected bool m_ControllerRightStickTimerEnd = true;
 protected ref Timer m_ControllerRightStickTimer;
 
 protected bool m_HoldingQB;
 protected InventoryItem m_QBHoveredItems;
 
 const float BT_REPEAT_DELAY = 0.35; //delay from first press to begin tick repeat state
 const float BT_REPEAT_TIME = 0.09; //tick repeat frequency time
 const float BT_THRESHOLD_VALUE = 0.8; //threshold values for analog inputs
 const int INV_MOV_LEFT = 0;
 const int INV_MOV_RIGHT = 1;
 const int INV_MOV_UP = 2;
 const int INV_MOV_DOWN = 3;
 protected ref array<string> m_InvInputNames = {"UAUILeftInventory","UAUIRightInventory","UAUIUpInventory","UAUIDownInventory"};
 protected ref array<UAIDWrapper> m_InvInputWrappers;
 protected ref array<float> m_InvInputTimes;
 protected int m_InvInputWrappersCount;
 protected float m_SensitivityThreshold = 0.0;
 UAInput m_InvUAInput;
 int m_InvInputActive = 0;
 
 void Inventory(LayoutHolder parent)
 {
 m_Instance = this;
 LoadPlayerAttachmentIndexes();
 
 m_ControllerRightStickTimer = new Timer();
 new ItemManager(GetMainWidget());
 new ColorManager();
 
 m_LeftArea = new LeftArea(this);
 m_RightArea = new RightArea(this);
 m_HandsArea = new HandsArea(this);
 m_PlayerPreview = new PlayerPreview(this);
 
 m_QuickbarWidget = GetMainWidget().FindAnyWidget("QuickbarGrid");
 m_Quickbar = new InventoryQuickbar(m_QuickbarWidget);
 m_Quickbar.UpdateItems(m_QuickbarWidget);
 
 m_SpecializationPanel = GetMainWidget().FindAnyWidget("SpecializationPanelPanel");
 m_SpecializationIcon = GetMainWidget().FindAnyWidget("SpecializationIcon");
 
 WidgetEventHandler.GetInstance().RegisterOnDropReceived(GetMainWidget().FindAnyWidget("LeftBackground"), this, "OnLeftPanelDropReceived");
 WidgetEventHandler.GetInstance().RegisterOnDraggingOver(GetMainWidget().FindAnyWidget("LeftBackground"), this, "DraggingOverLeftPanel");
 WidgetEventHandler.GetInstance().RegisterOnDropReceived(GetMainWidget().FindAnyWidget("LeftPanel").FindAnyWidget("Scroller"), this, "OnLeftPanelDropReceived");
 WidgetEventHandler.GetInstance().RegisterOnDraggingOver(GetMainWidget().FindAnyWidget("LeftPanel").FindAnyWidget("Scroller"), this, "DraggingOverLeftPanel");
 
 WidgetEventHandler.GetInstance().RegisterOnDropReceived(GetMainWidget().FindAnyWidget("RightBackground"), this, "OnRightPanelDropReceived");
 WidgetEventHandler.GetInstance().RegisterOnDraggingOver(GetMainWidget().FindAnyWidget("RightBackground"), this, "DraggingOverRightPanel");
 WidgetEventHandler.GetInstance().RegisterOnDropReceived(GetMainWidget().FindAnyWidget("RightPanel").FindAnyWidget("Scroller"), this, "OnRightPanelDropReceived");
 WidgetEventHandler.GetInstance().RegisterOnDraggingOver(GetMainWidget().FindAnyWidget("RightPanel").FindAnyWidget("Scroller"), this, "DraggingOverRightPanel");
 
 WidgetEventHandler.GetInstance().RegisterOnDropReceived(GetMainWidget().FindAnyWidget("CharacterPanel"), this, "OnCenterPanelDropReceived");
 WidgetEventHandler.GetInstance().RegisterOnDraggingOver(GetMainWidget().FindAnyWidget("CharacterPanel"), this, "DraggingOverCenterPanel");
 
 WidgetEventHandler.GetInstance().RegisterOnDropReceived(GetMainWidget().FindAnyWidget("HandsPanel"), this, "OnHandsPanelDropReceived");
 WidgetEventHandler.GetInstance().RegisterOnDraggingOver(GetMainWidget().FindAnyWidget("HandsPanel"), this, "DraggingOverHandsPanel");
 
 #ifdef PLATFORM_CONSOLE
 PluginDiagMenu plugin_diag_menu = PluginDiagMenu.Cast(GetPlugin(PluginDiagMenu));
 GetGame().GetUIManager().ShowUICursor(false);
 ResetFocusedContainers();
 GetMainWidget().FindAnyWidget("CursorCharacter").Show(false);
 
 //console inventory toolbar
 m_TopConsoleToolbarVicinity = GetRootWidget().FindAnyWidget("LBRB_Vicinity");
 m_TopConsoleToolbarHands = GetRootWidget().FindAnyWidget("LBRB_Hands");
 m_TopConsoleToolbarEquipment = GetRootWidget().FindAnyWidget("LBRB_Equipment");
 
 RichTextWidget.Cast(m_TopConsoleToolbarVicinity.FindAnyWidget("LBRB_Vicinity_LBIcon")).SetText(InputUtils.GetRichtextButtonIconFromInputAction("UAUIInventoryTabLeft", "", EUAINPUT_DEVICE_CONTROLLER));
 RichTextWidget.Cast(m_TopConsoleToolbarVicinity.FindAnyWidget("LBRB_Vicinity_RBIcon")).SetText(InputUtils.GetRichtextButtonIconFromInputAction("UAUIInventoryTabRight", "", EUAINPUT_DEVICE_CONTROLLER));
 RichTextWidget.Cast(m_TopConsoleToolbarHands.FindAnyWidget("LBRB_Hands_LBIcon")).SetText(InputUtils.GetRichtextButtonIconFromInputAction("UAUIInventoryTabLeft", "", EUAINPUT_DEVICE_CONTROLLER));
 RichTextWidget.Cast(m_TopConsoleToolbarHands.FindAnyWidget("LBRB_Hands_RBIcon")).SetText(InputUtils.GetRichtextButtonIconFromInputAction("UAUIInventoryTabRight", "", EUAINPUT_DEVICE_CONTROLLER));
 RichTextWidget.Cast(m_TopConsoleToolbarEquipment.FindAnyWidget("LBRB_Equipment_LBIcon")).SetText(InputUtils.GetRichtextButtonIconFromInputAction("UAUIInventoryTabLeft", "", EUAINPUT_DEVICE_CONTROLLER));
 RichTextWidget.Cast(m_TopConsoleToolbarEquipment.FindAnyWidget("LBRB_Equipment_RBIcon")).SetText(InputUtils.GetRichtextButtonIconFromInputAction("UAUIInventoryTabRight", "", EUAINPUT_DEVICE_CONTROLLER));
 
 m_BottomConsoleToolbar = GetRootWidget().FindAnyWidget("BottomConsoleToolbar");
 m_BottomConsoleToolbarRichText = RichTextWidget.Cast(GetRootWidget().FindAnyWidget("ContextToolbarText"));
 
 m_NeedUpdateConsoleToolbar = false;
 
 GetGame().GetMission().GetOnInputPresetChanged().Insert(OnInputPresetChanged);
 GetGame().GetMission().GetOnInputDeviceChanged().Insert(OnInputDeviceChanged);
 
 m_SpecializationPanel.Show(false);
 UpdateConsoleToolbar();
 InitInputWrapperData();
 #endif
 }
 
 void InitInputWrapperData()
 {
 int namesCount = m_InvInputNames.Count();
 m_InvInputWrappers = new array<UAIDWrapper>;
 m_InvInputTimes = new array<float>;
 
 for (int i = 0; i < namesCount; i++)
 {
 m_InvInputWrappers.Insert(GetUApi().GetInputByName(m_InvInputNames[i]).GetPersistentWrapper());
 m_InvInputTimes.Insert(0);
 }
 
 m_InvInputWrappersCount = m_InvInputWrappers.Count();
 }
 
 protected void OnInputPresetChanged()
 {
 #ifdef PLATFORM_CONSOLE
 UpdateConsoleToolbar();
 #endif
 }
 
 protected void OnInputDeviceChanged(EInputDeviceType pInputDeviceType)
 {
 switch (pInputDeviceType)
 {
 case EInputDeviceType.CONTROLLER:
 m_BottomConsoleToolbar.Show(true);
 UpdateConsoleToolbar();
 break;
 
 default:
 if (GetGame().GetInput().IsEnabledMouseAndKeyboardEvenOnServer())
 {
 m_BottomConsoleToolbar.Show(false);
 m_TopConsoleToolbarVicinity.Show(false);
 m_TopConsoleToolbarHands.Show(false);
 m_TopConsoleToolbarEquipment.Show(false);
 }
 break;
 }
 }
 
 static Inventory GetInstance()
 {
 return m_Instance;
 }
 
 void Serialize()
 {
 ItemManager.GetInstance().SerializeDefaultOpenStates();
 ItemManager.GetInstance().SerializeDefaultHeaderOpenStates();
 }
 
 void Deserialize()
 {
 ItemManager.GetInstance().DeserializeDefaultOpenStates();
 ItemManager.GetInstance().DeserializeDefaultHeaderOpenStates();
 }
 
 static int GetPlayerAttachmentIndex(string slot_name)
 {
 return m_PlayerAttachmentsIndexes[slot_name];
 }
 
 static int GetPlayerAttachmentIndex(int slot_id)
 {
 return GetPlayerAttachmentIndex(InventorySlots.GetSlotName(slot_id));
 }
 
 protected void LoadPlayerAttachmentIndexes()
 {
 int i; 
 string data, errorMessage;
 
 m_PlayerAttachmentsIndexes = new map<string, int>();
 
 if (GetGame().GetProfileString("INV_AttIndexes", data))
 {
 if (!JsonFileLoader<map<string, int>>.LoadData(data, m_PlayerAttachmentsIndexes, errorMessage))
 ErrorEx(errorMessage);
 }
 
 string configPathGhostSlots = "CfgVehicles SurvivorBase InventoryEquipment playerSlots";
 array<string> playerGhostSlots = new array<string>();
 GetGame().ConfigGetTextArray(configPathGhostSlots, playerGhostSlots);
 
 foreach (string slotName : playerGhostSlots)
 {
 slotName.Replace("Slot_", "");
 if (!m_PlayerAttachmentsIndexes.Contains(slotName) && InventorySlots.GetSlotIdFromString(slotName) != -1)
 {
 m_PlayerAttachmentsIndexes.Insert(slotName, m_PlayerAttachmentsIndexes.Count());
 }
 }
 
 if (!JsonFileLoader<map<string, int>>.MakeData(m_PlayerAttachmentsIndexes, data, errorMessage))
 ErrorEx(errorMessage);
 
 GetGame().SetProfileString("INV_AttIndexes", data);
 }
 
 static void MoveAttachmentUp(int slot_id)
 {
 int curr = GetPlayerAttachmentIndex(slot_id);
 
 int next_offset = 0;
 string next_item = "init";
 int next_id;
 EntityAI next_ent;
 
 while(!next_ent && next_item != "")
 {
 next_item = m_PlayerAttachmentsIndexes.GetKeyByValue(curr + --next_offset);
 next_id = InventorySlots.GetSlotIdFromString(next_item);
 next_ent = GetGame().GetPlayer().GetInventory().FindAttachment(next_id);
 if (next_ent && !m_Instance.m_RightArea.HasEntityContainerVisible(next_ent))
 next_ent = null;
 }
 
 if (next_item != "" && next_ent)
 {
 int next = GetPlayerAttachmentIndex(next_item);
 m_PlayerAttachmentsIndexes.Set(InventorySlots.GetSlotName(slot_id), next);
 m_PlayerAttachmentsIndexes.Set(next_item, curr);
 if (m_Instance)
 m_Instance.m_RightArea.SwapItemsInOrder(next_id, slot_id);
 }
 }
 
 static void MoveAttachmentDown(int slot_id)
 {
 int curr = GetPlayerAttachmentIndex(slot_id);
 
 int next_offset = 0;
 string next_item = "init";
 int next_id;
 EntityAI next_ent;
 
 while(!next_ent && next_item != "")
 {
 next_item = m_PlayerAttachmentsIndexes.GetKeyByValue(curr + ++next_offset);
 next_id = InventorySlots.GetSlotIdFromString(next_item);
 next_ent = GetGame().GetPlayer().GetInventory().FindAttachment(next_id);
 if (next_ent && !m_Instance.m_RightArea.HasEntityContainerVisible(next_ent))
 next_ent = null;
 }
 
 if (next_item != "" && next_ent)
 {
 int next = GetPlayerAttachmentIndex(next_item);
 m_PlayerAttachmentsIndexes.Set(InventorySlots.GetSlotName(slot_id), next);
 m_PlayerAttachmentsIndexes.Set(next_item, curr);
 if (m_Instance)
 m_Instance.m_RightArea.SwapItemsInOrder(next_id, slot_id);
 }
 }
 
 protected int GetProperControllerStickAngle(int angle)
 {
 int proper_angle = (360 - angle) % 360;
 return proper_angle;
 }
 
 protected int AngleToDirection(int angle)
 {
 if (angle < 45 || angle > 315)
 {
 return Direction.RIGHT;
 }
 else if (angle < 135 && angle > 45)
 {
 return Direction.DOWN;
 }
 else if (angle < 225 && angle > 135)
 {
 return Direction.LEFT;
 }
 else if (angle < 315 && angle > 225)
 {
 return Direction.UP;
 }
 return -1;
 }
 
 void TimerEnd()
 {
 m_ControllerRightStickTimerEnd = true;
 m_ControllerRightStickTimer.Stop();
 }
 
 bool Controller(Widget w, int control, int value)
 {
 #ifdef PLATFORM_CONSOLE
 
 //Right stick
 if (control == ControlID.CID_RADIALMENU)
 {
 m_ControllerAngle = value >> 4; // <0,360>
 m_ControllerTilt = value & 0xF; // <0,10>
 
 m_ControllerAngle = GetProperControllerStickAngle(m_ControllerAngle);
 
 m_ControllerAngle = AngleToDirection(m_ControllerAngle);
 
 if (m_ControllerTilt>5)
 {
 if (m_ControllerRightStickTimerEnd)
 {
 m_ControllerRightStickTimerEnd = false;
 m_ControllerRightStickTimer.Run(0.1, this, "TimerEnd");
 }
 }
 return true;
 }
 
 UpdateConsoleToolbar();
 #endif
 return false;
 }
 
 void DraggingOverHandsPanel(Widget w, int x, int y, Widget receiver)
 {
 ItemManager.GetInstance().HideDropzones();
 m_HandsArea.DraggingOverHandsPanel(w, x, y, receiver);
 }
 
 void OnHandsPanelDropReceived(Widget w, int x, int y, Widget receiver)
 {
 m_HandsArea.OnHandsPanelDropReceived(w, x, y, receiver);
 }
 
 void OnLeftPanelDropReceived(Widget w, int x, int y, Widget receiver)
 {
 m_LeftArea.OnLeftPanelDropReceived(w, x, y, receiver);
 }
 
 void OnRightPanelDropReceived(Widget w, int x, int y, Widget receiver)
 {
 if (w)
 {
 ItemPreviewWidget ipw = ItemPreviewWidget.Cast(w.FindAnyWidget("Render"));
 if (!ipw)
 {
 string name = w.GetName();
 name.Replace("PanelWidget", "Render");
 ipw = ItemPreviewWidget.Cast(w.FindAnyWidget(name));
 if (!ipw)
 {
 ipw = ItemPreviewWidget.Cast(w);
 if (!ipw)
 {
 return;
 }
 }
 }
 
 EntityAI item = ipw.GetItem();
 if (item)
 {
 PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
 InventoryLocation il = new InventoryLocation;
 if (player && player.GetInventory().FindFreeLocationFor(item, FindInventoryLocationType.CARGO | FindInventoryLocationType.ATTACHMENT, il))
 {
 SplitItemUtils.TakeOrSplitToInventory(player, player, item);
 }
 }
 }
 }
 
 void OnCenterPanelDropReceived(Widget w, int x, int y, Widget receiver)
 {
 if (w)
 {
 ItemPreviewWidget ipw = ItemPreviewWidget.Cast(w.FindAnyWidget("Render"));
 if (!ipw)
 {
 string name = w.GetName();
 name.Replace("PanelWidget", "Render");
 ipw = ItemPreviewWidget.Cast(w.FindAnyWidget(name));
 if (!ipw)
 {
 ipw = ItemPreviewWidget.Cast(w);
 if (!ipw)
 {
 return;
 }
 }
 }
 
 EntityAI item = ipw.GetItem();
 if (item)
 {
 if (!item.GetInventory().CanRemoveEntity())
 return;
 PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
 
 bool found = false;
 
 InventoryLocation inv_loc = new InventoryLocation;
 
 if (player)
 {
 int index = player.GetHumanInventory().FindUserReservedLocationIndex(item);
 if (index>=0)
 {
 player.GetHumanInventory().GetUserReservedLocation(index, inv_loc);
 if (player.GetInventory().LocationCanAddEntity(inv_loc))
 {
 SplitItemUtils.TakeOrSplitToInventoryLocation(player, inv_loc);
 }
 return;
 }
 
 } 
 
 if (player && (player.GetInventory().CanAddAttachment(item)))
 {
 float stackable = item.GetTargetQuantityMax(-1);
 
 if (stackable == 0 || stackable >= item.GetQuantity())
 {
 player.PredictiveTakeEntityAsAttachment(item);
 }
 else
 {
 InventoryLocation il = new InventoryLocation;
 player.GetInventory().FindFreeLocationFor(item, FindInventoryLocationType.ATTACHMENT, il);
 ItemBase.Cast(item).SplitIntoStackMaxToInventoryLocationClient(il);
 }
 }
 else
 {
 int slot_id = item.GetInventory().GetSlotId(0);
 EntityAI slot_item = player.GetInventory().FindAttachment(slot_id);
 if (slot_item && player.GetInventory().CanSwapEntitiesEx(item, slot_item))
 {
 player.PredictiveSwapEntities(item, slot_item);
 }
 else if (player.CanReceiveItemIntoCargo(item))
 {
 InventoryLocation dst = new InventoryLocation;
 player.GetInventory().FindFreeLocationFor(item, FindInventoryLocationType.ANY, dst);
 if (dst.IsValid())
 { 
 if (dst.GetType() == InventoryLocationType.HANDS && item.IsHeavyBehaviour())
 { 
 ActionManagerClient mngr_client;
 CastTo(mngr_client, player.GetActionManager());
 
 ActionTarget atrg = new ActionTarget(item, null, -1, vector.Zero, -1.0);
 if (mngr_client.GetAction(ActionTakeItemToHands).Can(player, atrg, null))
 mngr_client.PerformActionStart(mngr_client.GetAction(ActionTakeItemToHands), atrg, null);
 
 return;
 }
 
 SplitItemUtils.TakeOrSplitToInventoryLocation(player, dst);
 }
 }
 }
 }
 }
 }
 
 void DraggingOverLeftPanel(Widget w, int x, int y, Widget receiver)
 {
 m_LeftArea.DraggingOverHeader(w, x, y, receiver);
 }
 
 void DraggingOverRightPanel(Widget w, int x, int y, Widget receiver)
 {
 m_RightArea.DraggingOverHeader(w, x, y, receiver);
 }
 
 void DraggingOverCenterPanel(Widget w, int x, int y, Widget receiver)
 {
 if (w)
 {
 ItemPreviewWidget ipw = ItemPreviewWidget.Cast(w.FindAnyWidget("Render"));
 if (!ipw)
 {
 string name = w.GetName();
 name.Replace("PanelWidget", "Render");
 ipw = ItemPreviewWidget.Cast(w.FindAnyWidget(name));
 if (!ipw)
 {
 ipw = ItemPreviewWidget.Cast(w);
 if (!ipw)
 {
 return;
 }
 }
 }
 
 EntityAI item = ipw.GetItem();
 PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
 
 if (player && item)
 {
 int slot_id = item.GetInventory().GetSlotId(0);
 EntityAI slot_item = player.GetInventory().FindAttachment(slot_id);
 bool found = false;
 
 InventoryLocation inv_loc = new InventoryLocation;
 
 int index = player.GetHumanInventory().FindUserReservedLocationIndex(item);
 if (index>=0)
 {
 player.GetHumanInventory().GetUserReservedLocation(index, inv_loc);
 if (player.GetInventory().LocationCanAddEntity(inv_loc))
 found = true;
 }
 
 if (!found)
 {
 player.GetInventory().FindFreeLocationFor(item, FindInventoryLocationType.ANY, inv_loc);
 }
 
 
 if (inv_loc.IsValid())
 {
 ItemManager.GetInstance().HideDropzones();
 GetMainWidget().FindAnyWidget("RightPanel").FindAnyWidget("DropzoneX").SetAlpha(1);
 if (inv_loc.GetType() == 4)
 {
 ItemManager.GetInstance().HideDropzones();
 GetMainWidget().FindAnyWidget("HandsPanel").FindAnyWidget("DropzoneX").SetAlpha(1);
 }
 
 ColorManager.GetInstance().SetColor(w, ColorManager.GREEN_COLOR);
 }
 else
 {
 ItemManager.GetInstance().ShowSourceDropzone(item);
 ColorManager.GetInstance().SetColor(w, ColorManager.RED_COLOR);
 }
 }
 else
 {
 ColorManager.GetInstance().SetColor(w, ColorManager.RED_COLOR);
 }
 }
 }
 
 void Update(float timeslice)
 {
 #ifdef PLATFORM_CONSOLE
 //inventory grid movement
 InventoryMovementButtonTickHandler(timeslice);
 
 if (m_InvInputActive & (1 << INV_MOV_RIGHT))
 {
 if (GetUApi().GetInputByID(UAUIDragNDrop).LocalValue())
 {
 EnableMicromanagement();
 }
 
 if (!GetUApi().GetInputByID(UAUIInventoryTabRight).LocalValue())
 {
 if (m_RightArea.IsActive())
 m_RightArea.MoveGridCursor(Direction.RIGHT);
 if (m_LeftArea.IsActive())
 m_LeftArea.MoveGridCursor(Direction.RIGHT);
 if (m_HandsArea.IsActive())
 m_HandsArea.MoveGridCursor(Direction.RIGHT);
 }
 }
 else if (m_InvInputActive & (1 << INV_MOV_LEFT))
 {
 if (GetUApi().GetInputByID(UAUIDragNDrop).LocalValue())
 {
 EnableMicromanagement();
 }
 
 if (!GetUApi().GetInputByID(UAUIInventoryTabLeft).LocalValue())
 {
 if (m_RightArea.IsActive())
 m_RightArea.MoveGridCursor(Direction.LEFT);
 if (m_LeftArea.IsActive())
 m_LeftArea.MoveGridCursor(Direction.LEFT);
 if (m_HandsArea.IsActive())
 m_HandsArea.MoveGridCursor(Direction.LEFT);
 }
 }
 else if (m_InvInputActive & (1 << INV_MOV_UP))
 {
 if (GetUApi().GetInputByID(UAUIDragNDrop).LocalValue())
 {
 EnableMicromanagement();
 }
 
 if (!GetUApi().GetInputByID(UAUIInventoryContainerUp).LocalValue())
 {
 if (m_RightArea.IsActive())
 m_RightArea.MoveGridCursor(Direction.UP);
 if (m_LeftArea.IsActive())
 m_LeftArea.MoveGridCursor(Direction.UP);
 if (m_HandsArea.IsActive())
 m_HandsArea.MoveGridCursor(Direction.UP);
 }
 }
 else if (m_InvInputActive & (1 << INV_MOV_DOWN))
 {
 if (GetUApi().GetInputByID(UAUIDragNDrop).LocalValue())
 {
 EnableMicromanagement();
 }
 
 if (!GetUApi().GetInputByID(UAUIInventoryContainerDown).LocalValue())
 {
 if (m_RightArea.IsActive())
 m_RightArea.MoveGridCursor(Direction.DOWN);
 if (m_LeftArea.IsActive())
 m_LeftArea.MoveGridCursor(Direction.DOWN);
 if (m_HandsArea.IsActive())
 m_HandsArea.MoveGridCursor(Direction.DOWN);
 }
 }
 
 m_InvInputActive = 0;
 #endif
 
 UpdateInterval();
 }
 
 UAInput m_InpInp = null;
 override void UpdateInterval()
 {
 PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
 InventoryItem item;
 if (GetUApi().GetInputByID(UAUIRotateInventory).LocalPress())
 {
 item = InventoryItem.Cast(ItemManager.GetInstance().GetDraggedItem());
 if (item)
 {
 int size_x, size_y;
 GetGame().GetInventoryItemSize(item, size_x, size_y);
 if (size_x != size_y)
 {
 item.GetInventory().FlipCargo();
 item.GetOnItemFlipped().Invoke(item.GetInventory().GetFlipCargo());
 }
 }
 }
 
 #ifdef PLATFORM_CONSOLE
 DayZPlayerInventory dpi;
 if (player)
 dpi = player.GetDayZPlayerInventory();
 
 // There's a second one a bit below
 if (dpi && !dpi.IsProcessing())
 {
 if (GetUApi().GetInputByID(UAUIExpandCollapseContainer).LocalPress())
 {
 if (m_RightArea.IsActive())
 {
 m_RightArea.ExpandCollapseContainer();
 }
 else if (m_LeftArea.IsActive())
 {
 m_LeftArea.ExpandCollapseContainer();
 }
 }
 
 if (GetUApi().GetInputByID(UAUIDragNDrop).LocalHoldBegin())
 {
 EnableMicromanagement();
 }
 
 if (GetUApi().GetInputByID(UAUISplit).LocalPress())
 {
 if (m_HandsArea.IsActive())
 {
 if (m_HandsArea.SplitItem())
 {
 m_HandsArea.SetActive(false);
 m_HandsArea.UnfocusGrid();
 m_RightArea.SetActive(true);
 }
 }
 else if (m_RightArea.IsActive())
 {
 m_RightArea.SplitItem();
 }
 else if (m_LeftArea.IsActive())
 {
 m_LeftArea.SplitItem();
 }
 
 HideOwnedTooltip();
 }
 
 if (GetUApi().GetInputByID(UAUIFastEquip).LocalPress())
 {
 if (m_HandsArea.IsActive())
 {
 if (m_HandsArea.EquipItem())
 {
 m_HandsArea.SetActive(false);
 m_HandsArea.UnfocusGrid();
 m_RightArea.SetActive(true);
 }
 }
 else if (m_RightArea.IsActive())
 {
 m_RightArea.EquipItem();
 }
 else if (m_LeftArea.IsActive())
 {
 m_LeftArea.EquipItem();
 }
 
 UpdateConsoleToolbar();
 HideOwnedTooltip();
 }
 
 if (ItemManager.GetInstance().IsMicromanagmentMode() && GetUApi().GetInputByID(UAUIDragNDrop).LocalRelease())
 {
 if (m_RightArea.IsActive())
 {
 m_RightArea.Select();
 }
 else if (m_LeftArea.IsActive())
 {
 m_LeftArea.Select();
 }
 else if (m_HandsArea.IsActive())
 {
 m_HandsArea.Select();
 }
 
 DisableMicromanagement();
 UpdateConsoleToolbar();
 }
 if (GetUApi().GetInputByID(UAUIPutInHandsFromVicinity).LocalPress())
 {
 if (m_LeftArea.IsActive())
 {
 if (m_LeftArea.Select())
 {
 m_LeftArea.SetActive(false);
 m_LeftArea.UnfocusGrid();
 m_HandsArea.SetActive(true);
 
 UpdateConsoleToolbar();
 }
 }
 }
 if (GetUApi().GetInputByID(UAUIPutInHandsFromInventory).LocalPress())
 {
 if (m_RightArea.IsActive())
 {
 if (m_RightArea.Select())
 {
 m_RightArea.SetActive(false);
 m_RightArea.UnfocusGrid();
 m_HandsArea.SetActive(true);
 
 UpdateConsoleToolbar();
 }
 }
 }
 
 if (GetUApi().GetInputByID(UAUIFastTransferToVicinity).LocalPress()) //item drop
 {
 if (m_HandsArea.IsActive())
 {
 item = InventoryItem.Cast(m_HandsArea.GetFocusedItem());
 if (item && item.GetInventory().CanRemoveEntity())
 {
 if (m_HandsArea.TransferItemToVicinity())
 {
 m_HandsArea.SetActive(false);
 m_HandsArea.UnfocusGrid();
 m_LeftArea.SetActive(true);
 m_HadFastTransferred = true;
 }
 }
 }
 else if (m_RightArea.IsActive())
 {
 item = InventoryItem.Cast(m_RightArea.GetFocusedItem());
 if (item && item.GetInventory().CanRemoveEntity())
 {
 if (m_RightArea.TransferItemToVicinity())
 m_HadFastTransferred = true;
 }
 }
 
 UpdateConsoleToolbar();
 HideOwnedTooltip();
 }
 }
 
 if (GetUApi().GetInputByID(UAUIInspectItem).LocalPress())
 {
 if (m_HandsArea.IsActive())
 {
 if (m_HandsArea.InspectItem())
 {
 m_HadInspected = true;
 }
 }
 else if (m_RightArea.IsActive())
 {
 if (m_RightArea.InspectItem())
 {
 m_HadInspected = true;
 }
 }
 else if (m_LeftArea.IsActive())
 {
 if (m_LeftArea.InspectItem())
 {
 m_HadInspected = true;
 }
 }
 
 UpdateConsoleToolbar();
 }
 
 if (GetUApi().GetInputByID(UAUIFastTransferItem).LocalPress())
 m_HadFastTransferred = false;
 
 if (GetUApi().GetInputByID(UAUIInspectItem).LocalPress())
 m_HadInspected = false;
 
 if (dpi && !dpi.IsProcessing())
 {
 if (!m_HadFastTransferred && GetUApi().GetInputByID(UAUIFastTransferItem).LocalPress()) //transfers item to inventory (not hands, or hands last?)
 {
 if (m_LeftArea.IsActive())
 {
 item = InventoryItem.Cast(m_LeftArea.GetFocusedItem());
 if (item && item.GetInventory().CanRemoveEntity())
 {
 m_LeftArea.TransferItem();
 }
 }
 else if (m_HandsArea.IsActive())
 {
 item = InventoryItem.Cast(m_HandsArea.GetFocusedItem());
 if (item && item.GetInventory().CanRemoveEntity())
 {
 if (m_HandsArea.TransferItem())
 {
 m_HandsArea.SetActive(false);
 m_HandsArea.UnfocusGrid();
 m_RightArea.SetActive(true);
 }
 }
 }
 
 UpdateConsoleToolbar();
 HideOwnedTooltip();
 }
 }
 
 if (GetUApi().GetInputByID(UAUIInventoryContainerUp).LocalPress())
 {
 if (GetUApi().GetInputByID(UAUIDragNDrop).LocalValue())
 {
 EnableMicromanagement();
 }
 
 MoveFocusByContainer(Direction.UP);
 }
 
 if (GetUApi().GetInputByID(UAUIInventoryContainerDown).LocalPress())
 {
 if (GetUApi().GetInputByID(UAUIDragNDrop).LocalValue())
 {
 EnableMicromanagement();
 }
 
 MoveFocusByContainer(Direction.DOWN);
 }
 
 if (GetUApi().GetInputByID(UAUIInventoryTabLeft).LocalPress())
 {
 if (GetUApi().GetInputByID(UAUIDragNDrop).LocalValue())
 {
 EnableMicromanagement();
 }
 
 MoveFocusByArea(Direction.LEFT);
 }
 
 if (GetUApi().GetInputByID(UAUIInventoryTabRight).LocalPress())
 {
 if (GetUApi().GetInputByID(UAUIDragNDrop).LocalValue())
 {
 EnableMicromanagement();
 }
 
 MoveFocusByArea(Direction.RIGHT);
 }
 
 //Open Quickbar radial menu
 if (GetUApi().GetInputByID(UAUIQuickbarRadialInventoryOpen).LocalPress())
 {
 //assign item
 EntityAI item_to_assign;
 
 if (m_HandsArea.IsActive())
 {
 player = PlayerBase.Cast(GetGame().GetPlayer());
 item_to_assign = player.GetItemInHands();
 m_HandsArea.AddItemToQuickbarRadial(item_to_assign);
 }
 else if (m_RightArea.IsActive())
 {
 item_to_assign = m_RightArea.GetFocusedItem();
 m_RightArea.AddItemToQuickbarRadial(item_to_assign);
 }
 }
 #endif
 
 MissionGameplay mission = MissionGameplay.Cast(GetGame().GetMission());
 if (!m_HadInspected && GetUApi().GetInputByID(UAUICombine).LocalPress())
 {
 if (GetMainWidget().IsVisible())
 {
 #ifdef PLATFORM_CONSOLE
 //DisableMicromanagement();
 if (m_RightArea.IsActive())
 {
 if (m_RightArea.CanCombine())
 {
 if (m_RightArea.Combine())
 {
 mission.HideInventory();
 }
 }
 }
 else if (m_LeftArea.IsActive())
 {
 if (m_LeftArea.CanCombine())
 {
 if (m_LeftArea.Combine())
 {
 mission.HideInventory();
 }
 }
 }
 #endif
 }
 }
 
 if (!m_HadInspected && GetUApi().GetInputByID(UAUIBack).LocalPress())
 {
 mission.HideInventory();
 }
 
 for (int i = 0; i < 10; i++)
 {
 if (!m_HoldingQB && GetUApi().GetInputByName("UAItem" + i).LocalPress())
 {
 m_QBHoveredItems = InventoryItem.Cast(ItemManager.GetInstance().GetHoveredItem());
 m_HoldingQB = true;
 }
 
 if (m_HoldingQB && GetUApi().GetInputByName("UAItem" + i).LocalHold())
 {
 
 AddQuickbarItem(m_QBHoveredItems, i);
 m_QBHoveredItems = null;
 m_HoldingQB = false;
 }
 }
 
 m_LeftArea.UpdateInterval();
 m_RightArea.UpdateInterval();
 m_HandsArea.UpdateInterval();
 m_PlayerPreview.UpdateInterval();
 
 #ifdef PLATFORM_CONSOLE
 UpdateConsoleToolbarCheck();
 #endif
 }
 
 void AddQuickbarItem(InventoryItem item, int index)
 {
 PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
 
 if (item && item.GetInventory().CanRemoveEntity())
 {
 player.SetQuickBarEntityShortcut(item, index) ;
 }
 
 InventoryMenu menu = InventoryMenu.Cast(GetGame().GetUIManager().FindMenu(MENU_INVENTORY));
 if (menu)
 {
 menu.RefreshQuickbar();
 }
 }
 
 void EnableMicromanagement()
 {
 if (!ItemManager.GetInstance().IsMicromanagmentMode())
 {
 ItemManager.GetInstance().SetItemMicromanagmentMode(true);
 if (m_RightArea.IsActive())
 {
 m_RightArea.SelectItem();
 }
 else if (m_LeftArea.IsActive())
 {
 m_LeftArea.SelectItem();
 }
 else if (m_HandsArea.IsActive())
 {
 m_HandsArea.SelectItem();
 }
 
 UpdateConsoleToolbar();
 HideOwnedTooltip();
 }
 }
 
 void DisableMicromanagement()
 {
 if (ItemManager.GetInstance().IsMicromanagmentMode())
 {
 ItemManager.GetInstance().SetItemMicromanagmentMode(false);
 ItemManager.GetInstance().SetSelectedItemEx(null, null, null);
 UpdateConsoleToolbar();
 HideOwnedTooltip();
 }
 }
 
 override void SetLayoutName()
 {
 #ifdef PLATFORM_CONSOLE
 m_LayoutName = WidgetLayoutName.InventoryXbox;
 #else
 switch (InventoryMenu.GetWidthType())
 {
 case ScreenWidthType.NARROW:
 {
 m_LayoutName = WidgetLayoutName.InventoryNarrow;
 break;
 }
 case ScreenWidthType.MEDIUM:
 {
 m_LayoutName = WidgetLayoutName.InventoryMedium;
 break;
 }
 case ScreenWidthType.WIDE:
 {
 m_LayoutName = WidgetLayoutName.InventoryWide;
 break;
 }
 }
 #endif
 }
 
 void Init() {}
 
 void Reset()
 {
 m_LeftArea.Refresh();
 m_RightArea.Refresh();
 m_HandsArea.Refresh();
 }
 
 void ResetFocusedContainers()
 {
 #ifdef PLATFORM_CONSOLE
 m_RightArea.UnfocusGrid();
 m_LeftArea.UnfocusGrid();
 m_HandsArea.UnfocusGrid();
 
 m_LeftArea.SetActive(false);
 m_HandsArea.SetActive(false);
 m_RightArea.SetActive(false);
 
 m_RightArea.ResetFocusedContainer();
 m_LeftArea.ResetFocusedContainer();
 
 m_RightArea.SetActive(true);
 #endif
 }
 
 override void OnShow()
 {
 SetFocus(GetMainWidget());
 Deserialize();
 
 PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
 if (player && player.IsPlacingLocal())
 {
 GetGame().GetCallQueue(CALL_CATEGORY_SYSTEM).Call(player.TogglePlacingLocal);
 }
 
 Mission mission = GetGame().GetMission();
 if (mission)
 {
 IngameHud hud = IngameHud.Cast(mission.GetHud());
 if (hud)
 {
 hud.ShowQuickbarUI(false);
 hud.ShowHudInventory(true);
 }
 }
 
 UpdateSpecialtyMeter();
 
 #ifdef PLATFORM_CONSOLE
 ResetFocusedContainers();
 #endif 
 
 RefreshQuickbar();
 UpdateInterval();
 UpdateConsoleToolbar();
 
 m_HadFastTransferred = false;
 m_HadInspected = false;
 
 m_PlayerPreview.RefreshPlayerPreview();
 }
 
 override void OnHide()
 {
 Serialize();
 HideOwnedTooltip();
 Mission mission = GetGame().GetMission();
 if (mission)
 {
 IngameHud hud = IngameHud.Cast(mission.GetHud());
 if (hud)
 {
 hud.ShowQuickbarUI(true);
 hud.ShowHudInventory(false);
 }
 }
 ItemManager.GetInstance().SetSelectedItemEx(null, null, null);
 }
 
 void UpdateSpecialtyMeter()
 {
 PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
 if (player && player.GetSoftSkillsManager())
 {
 float x = player.GetSoftSkillsManager().GetSpecialtyLevel() / 2;
 float y = -0.75;
 #ifndef PLATFORM_CONSOLE
 m_SpecializationIcon.SetPos(x, y, true);
 #else
 Mission mission = GetGame().GetMission();
 IngameHud hud = IngameHud.Cast(mission.GetHud());
 if (hud)
 {
 hud.UpdateSpecialtyMeter(x,y);
 }
 #endif
 }
 }
 
 override void Refresh()
 {
 m_LeftArea.Refresh();
 m_HandsArea.Refresh();
 m_RightArea.Refresh();
 
 RefreshQuickbar();
 UpdateConsoleToolbar();
 }
 
 void RefreshQuickbar()
 {
 #ifndef PLATFORM_CONSOLE
 m_QuickbarWidget.Show(true);
 #else
 m_QuickbarWidget.Show(GetGame().GetInput().IsEnabledMouseAndKeyboardEvenOnServer());
 #endif
 
 #ifndef PLATFORM_CONSOLE
 if (m_Quickbar)
 #else
 if (m_Quickbar && GetGame().GetInput().IsEnabledMouseAndKeyboardEvenOnServer())
 #endif
 {
 m_Quickbar.UpdateItems(m_QuickbarWidget);
 }
 }
 
 
 #ifdef PLATFORM_CONSOLE
 protected string GetConsoleToolbarText(int mask)
 {
 string result = "";
 
 string toHandsSwapVicinity = string.Format(" %1", InputUtils.GetRichtextButtonIconFromInputAction("UAUIPutInHandsFromVicinity", GetStringVariant("UAUIPutInHandsFromVicinity",{"#STR_Controls_TakeInHandsSwap","#STR_USRACT_HoldToHandSwap",""}), EUAINPUT_DEVICE_CONTROLLER, InputUtils.ICON_SCALE_TOOLBAR));
 string toHandsSwapInv = string.Format(" %1", InputUtils.GetRichtextButtonIconFromInputAction("UAUIPutInHandsFromInventory", GetStringVariant("UAUIPutInHandsFromInventory",{"#STR_Controls_TakeInHandsSwap","#STR_USRACT_HoldToHandSwap",""}), EUAINPUT_DEVICE_CONTROLLER, InputUtils.ICON_SCALE_TOOLBAR));
 string drop = string.Format(" %1", InputUtils.GetRichtextButtonIconFromInputAction("UAUIFastTransferToVicinity", "#dayz_context_menu_drop", EUAINPUT_DEVICE_CONTROLLER, InputUtils.ICON_SCALE_TOOLBAR));
 string equip = string.Format(" %1", InputUtils.GetRichtextButtonIconFromInputAction("UAUIFastEquip", "#dayz_context_menu_equip", EUAINPUT_DEVICE_CONTROLLER, InputUtils.ICON_SCALE_TOOLBAR));
 string split = string.Format(" %1", InputUtils.GetRichtextButtonIconFromInputAction("UAUISplit", GetStringVariant("UAUISplit",{"#dayz_context_menu_split","#STR_Controls_HoldSplit",""}), EUAINPUT_DEVICE_CONTROLLER, InputUtils.ICON_SCALE_TOOLBAR));
 string toInventory = string.Format(" %1", InputUtils.GetRichtextButtonIconFromInputAction("UAUIFastTransferItem", "#dayz_context_menu_to_inventory", EUAINPUT_DEVICE_CONTROLLER, InputUtils.ICON_SCALE_TOOLBAR));
 string openCloseContainer = string.Format(" %1", InputUtils.GetRichtextButtonIconFromInputAction("UAUIExpandCollapseContainer", "#dayz_context_menu_open_close", EUAINPUT_DEVICE_CONTROLLER, InputUtils.ICON_SCALE_TOOLBAR));
 string micromanagment = string.Format(" %1", InputUtils.GetRichtextButtonIconFromInputAction("UAUIDragNDrop", "#dayz_context_menu_micro", EUAINPUT_DEVICE_CONTROLLER, InputUtils.ICON_SCALE_TOOLBAR));
 string quickslot = string.Format(" %1", InputUtils.GetRichtextButtonIconFromInputAction("UAUIQuickbarRadialInventoryOpen", "#ps4_dayz_context_menu_quickslot", EUAINPUT_DEVICE_CONTROLLER, InputUtils.ICON_SCALE_TOOLBAR));
 string combine = string.Format(" %1", InputUtils.GetRichtextButtonIconFromInputAction("UAUICombine", GetStringVariant("UAUICombine",{"#dayz_context_menu_combine","#dayz_context_menu_combine_hold",""}), EUAINPUT_DEVICE_CONTROLLER, InputUtils.ICON_SCALE_TOOLBAR));
 
 if (mask & ConsoleActionToolbarMask.OPEN_CLOSE_CONTAINER)
 {
 result += openCloseContainer;
 } 
 if (mask & ConsoleActionToolbarMask.TO_HANDS_SWAP_VICINITY)
 {
 result += toHandsSwapVicinity;
 }
 if (mask & ConsoleActionToolbarMask.TO_HANDS_SWAP_INVENTORY)
 {
 result += toHandsSwapInv;
 }
 if (mask & ConsoleActionToolbarMask.TO_INVENTORY)
 {
 result += toInventory;
 }
 if (mask & ConsoleActionToolbarMask.DROP)
 {
 result += drop;
 }
 if (mask & ConsoleActionToolbarMask.SPLIT)
 {
 result += split;
 }
 if (mask & ConsoleActionToolbarMask.EQUIP)
 {
 result += equip;
 }
 if (mask & ConsoleActionToolbarMask.COMBINE)
 {
 result += combine;
 }
 if (mask & ConsoleActionToolbarMask.MICROMANAGMENT)
 {
 result += micromanagment;
 }
 if (mask & ConsoleActionToolbarMask.QUICKSLOT)
 {
 result += quickslot;
 }
 
 return result;
 }
 #endif
 
 Container GetFocusedArea()
 {
 if (m_LeftArea && m_LeftArea.IsActive())
 {
 return m_LeftArea;
 }
 else if (m_RightArea && m_RightArea.IsActive())
 {
 return m_RightArea;
 }
 else if (m_HandsArea && m_HandsArea.IsActive())
 {
 return m_HandsArea;
 }
 return null;
 }
 
 #ifdef PLATFORM_CONSOLE
 void UpdateConsoleToolbarCheck()
 {
 if ( m_NeedUpdateConsoleToolbar )
 {
 PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
 if (player.GetInventory().GetAnyInventoryReservationCount() == 0)
 {
 m_NeedUpdateConsoleToolbar = false;
 UpdateConsoleToolbar();
 }
 }
 }
 #endif
 
 //Console toolbar
 void UpdateConsoleToolbar()
 {
 #ifdef PLATFORM_CONSOLE
 int combinationFlag = 0;
 string contextualText;
 InventoryLocation il;
 
 Container focusedArea = GetFocusedArea();
 if (focusedArea)
 {
 Container focusedContainer = GetFocusedArea().GetFocusedContainer();
 EntityAI focusedItem = GetFocusedArea().GetFocusedItem();
 
 if (!(focusedItem && focusedItem.IsSetForDeletion()))
 {
 if (focusedContainer)
 {
 if (focusedItem)
 {
 il = new InventoryLocation;
 focusedItem.GetInventory().GetCurrentInventoryLocation( il );
 }
 
 bool canBeManipulated = false;
 PlayerBase player;
 PlayerBase itemPlayerOwner;
 
 player = PlayerBase.Cast(GetGame().GetPlayer());
 
 m_NeedUpdateConsoleToolbar = player.GetInventory().GetAnyInventoryReservationCount() > 0;
 
 if (focusedItem)
 {
 itemPlayerOwner = PlayerBase.Cast(focusedItem.GetHierarchyRootPlayer());
 il = new InventoryLocation;
 focusedItem.GetInventory().GetCurrentInventoryLocation( il );
 
 canBeManipulated = !player.GetInventory().HasInventoryReservation( focusedItem, null ) && !player.GetInventory().IsInventoryLocked() && !player.IsItemsToDelete();
 m_NeedUpdateConsoleToolbar |= !canBeManipulated;
 canBeManipulated = canBeManipulated && focusedItem.CanPutIntoHands(null);
 canBeManipulated = canBeManipulated && focusedItem.GetInventory().CanRemoveEntity();
 
 EntityAI parent = il.GetParent();
 if ( parent && il.GetType() == InventoryLocationType.ATTACHMENT )
 {
 canBeManipulated = canBeManipulated && AttachmentsOutOfReach.IsAttachmentReachable( parent, "", il.GetSlot() );
 canBeManipulated = canBeManipulated && !parent.GetInventory().GetSlotLock( il.GetSlot() );
 }
 
 if (canBeManipulated)
 {
 if (!ItemManager.GetInstance().IsMicromanagmentMode())
 {
 combinationFlag |= ConsoleActionToolbarMask.MICROMANAGMENT;
 }
 
 if (focusedContainer.CanEquipEx(focusedItem))
 {
 combinationFlag |= ConsoleActionToolbarMask.EQUIP;
 }
 
 if (player!= null && player == itemPlayerOwner)
 {
 if (focusedContainer.CanSwapOrTakeToHandsEx(focusedItem))
 {
 combinationFlag |= ConsoleActionToolbarMask.TO_HANDS_SWAP_INVENTORY;
 }
 
 if (focusedContainer.CanDropEx(focusedItem))
 {
 combinationFlag |= ConsoleActionToolbarMask.DROP;
 }
 }
 else
 {
 if (focusedContainer.CanSwapOrTakeToHandsEx(focusedItem))
 {
 combinationFlag |= ConsoleActionToolbarMask.TO_HANDS_SWAP_VICINITY;
 }
 }
 
 if (focusedContainer.CanCombineEx(focusedItem))
 {
 combinationFlag |= ConsoleActionToolbarMask.COMBINE;
 }
 
 if (focusedContainer.CanSplitEx(focusedItem))
 {
 combinationFlag |= ConsoleActionToolbarMask.SPLIT;
 }
 
 if (focusedArea.CanTakeToInventoryEx(focusedItem))
 {
 combinationFlag |= ConsoleActionToolbarMask.TO_INVENTORY;
 }
 }
 }
 
 if (focusedContainer.CanOpenCloseContainerEx(focusedItem))
 {
 combinationFlag |= ConsoleActionToolbarMask.OPEN_CLOSE_CONTAINER;
 }
 
 if (player!= null && focusedContainer.CanAddToQuickbarEx(focusedItem))
 {
 combinationFlag |= ConsoleActionToolbarMask.QUICKSLOT;
 }
 }
 }
 contextualText = GetConsoleToolbarText(combinationFlag);
 if (m_TopConsoleToolbarVicinity)
 m_TopConsoleToolbarVicinity.Show(m_LeftArea.IsActive());
 if (m_TopConsoleToolbarHands)
 m_TopConsoleToolbarHands.Show(m_HandsArea.IsActive());
 if (m_TopConsoleToolbarEquipment)
 m_TopConsoleToolbarEquipment.Show(m_RightArea.IsActive());
 if (m_BottomConsoleToolbarRichText)
 m_BottomConsoleToolbarRichText.SetText(contextualText + " ");
 }
 #endif
 }
 
 string GetStringVariant(string pInputAction, notnull array<string> variants)
 {
 if (variants.Count() != 3)
 {
 ErrorEx("wrong array count!");
 return "";
 }
 
 UAInput inp = GetUApi().GetInputByName(pInputAction);
 if (!inp.IsLimited() || inp.IsClickLimit()) //returns 'click' (no extension) variant as default
 {
 return variants[0];
 }
 if (inp.IsHoldLimit() || inp.IsHoldBeginLimit())
 {
 return variants[1];
 }
 if (inp.IsDoubleClickLimit())
 {
 return variants[2];
 }
 ErrorEx("Unhandled limiter exception!");
 return "";
 }
 
 void MoveFocusByContainer(int direction)
 {
 HideOwnedTooltip();
 
 if (direction == Direction.UP)
 {
 if ( m_LeftArea.IsActive() )
 {
 m_LeftArea.SetSameLevelPreviousActive();
 }
 else if ( m_RightArea.IsActive() )
 {
 m_RightArea.SetSameLevelPreviousActive();
 }
 else if ( m_HandsArea.IsActive() )
 {
 m_HandsArea.SetSameLevelPreviousActive();
 }
 
 UpdateConsoleToolbar();
 }
 else if (direction == Direction.DOWN)
 {
 if ( m_LeftArea.IsActive() )
 {
 m_LeftArea.SetSameLevelNextActive();
 }
 else if ( m_RightArea.IsActive() )
 {
 m_RightArea.SetSameLevelNextActive();
 }
 else if ( m_HandsArea.IsActive() )
 {
 m_HandsArea.SetSameLevelNextActive();
 }
 
 UpdateConsoleToolbar();
 }
 }
 
 void MoveFocusByArea(int direction)
 {
 HideOwnedTooltip();
 PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
 
 if (direction == Direction.LEFT)
 {
 if (m_LeftArea.IsActive())
 {
 if (!ItemManager.GetInstance().IsMicromanagmentMode())
 {
 m_LeftArea.UnfocusGrid();
 }
 m_LeftArea.SetActive(false);
 m_RightArea.SetActive(true);
 
 UpdateConsoleToolbar();
 }
 else if (m_RightArea.IsActive())
 {
 if (!ItemManager.GetInstance().IsMicromanagmentMode())
 {
 m_RightArea.UnfocusGrid();
 }
 m_RightArea.SetActive(false);
 player = PlayerBase.Cast(GetGame().GetPlayer());
 EntityAI item_in_hands = player.GetItemInHands();
 m_HandsArea.SetActive(true);
 
 UpdateConsoleToolbar();
 }
 else if (m_HandsArea.IsActive())
 {
 m_HandsArea.UnfocusGrid();
 m_HandsArea.SetActive(false);
 m_LeftArea.SetActive(true);
 
 UpdateConsoleToolbar();
 }
 }
 else if (direction == Direction.RIGHT)
 {
 if (m_LeftArea.IsActive())
 {
 if (!ItemManager.GetInstance().IsMicromanagmentMode())
 {
 m_LeftArea.UnfocusGrid();
 }
 m_LeftArea.SetActive(false);
 player = PlayerBase.Cast(GetGame().GetPlayer());
 item_in_hands = player.GetItemInHands();
 m_HandsArea.SetActive(true);
 
 UpdateConsoleToolbar();
 }
 else if (m_RightArea.IsActive())
 {
 if (!ItemManager.GetInstance().IsMicromanagmentMode())
 {
 m_RightArea.UnfocusGrid();
 }
 m_RightArea.SetActive(false);
 m_LeftArea.SetActive(true);
 
 UpdateConsoleToolbar();
 }
 else if (m_HandsArea.IsActive())
 {
 m_HandsArea.UnfocusGrid();
 m_HandsArea.SetActive(false);
 m_RightArea.SetActive(true);
 
 UpdateConsoleToolbar();
 }
 }
 }
 
 void InventoryMovementButtonTickHandler(float timeslice)
 {
 float tickvalue = 0;
 
 if (m_SensitivityThreshold > 0.0)
 {
 if (m_SensitivityThreshold < BT_REPEAT_TIME) //sensitivity solution...
 {
 m_SensitivityThreshold += timeslice;
 return;
 }
 else
 {
 m_SensitivityThreshold = 0.0;
 }
 }
 
 for (int i = 0; i < m_InvInputWrappersCount; i++)
 {
 m_InvUAInput = m_InvInputWrappers[i].InputP();
 
 if (m_InvUAInput.LocalValue() > BT_THRESHOLD_VALUE)
 {
 tickvalue = m_InvInputTimes[i];
 tickvalue += timeslice;
 }
 else
 {
 tickvalue = 0.0;
 }
 
 if (tickvalue < BT_REPEAT_DELAY && m_InvUAInput.LocalPress())
 {
 m_InvInputActive |= (1 << i);
 m_SensitivityThreshold += timeslice;
 }
 else if (tickvalue > (BT_REPEAT_DELAY + BT_REPEAT_TIME))
 {
 while (tickvalue > (BT_REPEAT_DELAY + BT_REPEAT_TIME))
 {
 tickvalue -= BT_REPEAT_TIME;
 }
 
 m_InvInputActive |= (1 << i);
 m_SensitivityThreshold += timeslice;
 }
 else
 {
 m_InvInputActive &= ~(1 << i);
 }
 
 m_InvInputTimes[i] = tickvalue;
 }
 }
}