vicinityslotscontainer.c

Go to the documentation of this file.

class VicinitySlotsContainer: Container
{
    protected ref AttachmentsGroupContainer     m_Container;
    protected int                               m_ItemsCount;
    protected int                               m_SlotsCount;
    protected ref array<EntityAI>               m_ShowedItems;
    
    void VicinitySlotsContainer( LayoutHolder parent )
    {
        m_Container = new AttachmentsGroupContainer(this);
        ref SlotsContainer con = new SlotsContainer( m_Container, null );
        m_Container.Insert( con );
        m_Body.Insert( m_Container );
        for( int j = 0; j < ITEMS_IN_ROW; j++ )
        {
            SlotsIcon icon = con.GetSlotIcon( j );
            WidgetEventHandler.GetInstance().RegisterOnDropReceived( icon.GetPanelWidget(),  m_Parent, "OnDropReceivedFromIcon" );
            WidgetEventHandler.GetInstance().RegisterOnDropReceived( icon.GetGhostSlot(),  m_Parent, "OnDropReceivedFromHeader" );
            WidgetEventHandler.GetInstance().RegisterOnDropReceived( icon.GetMainWidget(),  m_Parent, "OnDropReceivedFromHeader" );
            
            WidgetEventHandler.GetInstance().RegisterOnDraggingOver( icon.GetPanelWidget(),  m_Parent, "DraggingOverIcon" );
            WidgetEventHandler.GetInstance().RegisterOnDraggingOver( icon.GetGhostSlot(),  m_Parent, "DraggingOverHeader" );
            WidgetEventHandler.GetInstance().RegisterOnDraggingOver( icon.GetMainWidget(),  m_Parent, "DraggingOverHeader" );
            
            WidgetEventHandler.GetInstance().RegisterOnDoubleClick( icon.GetPanelWidget(),  this, "DoubleClick" );
            WidgetEventHandler.GetInstance().RegisterOnMouseButtonUp( icon.GetPanelWidget(),  this, "MouseClick" );
            WidgetEventHandler.GetInstance().RegisterOnMouseButtonDown( icon.GetPanelWidget(),  this, "MouseButtonDown" );
        }
        
        con.SetColumnCount(0);
        con.SetForceShow(true);
        
        WidgetEventHandler.GetInstance().RegisterOnDropReceived( m_Container.GetMainWidget(),  m_Parent, "OnDropReceivedFromHeader" );
        WidgetEventHandler.GetInstance().RegisterOnDraggingOver( m_Container.GetMainWidget(),  m_Parent, "DraggingOverHeader" );
        
        m_ShowedItems = new array<EntityAI>;
    }
    
    bool IsItemWithContainerActive()
    {
        EntityAI ent = GetFocusedItem();
        return ent && ( ent.GetInventory().GetCargo() || (ent.GetSlotsCountCorrect() > 0 && ent.CanDisplayAnyAttachmentSlot()) );
        //TODO: also check for cargo visibility maybe?
    }
    
    override bool IsItemWithQuantityActive()
    {
        EntityAI ent = GetFocusedItem();
        return ent && QuantityConversions.HasItemQuantity( ent ) && ent.CanBeSplit();
    }
    
    override bool IsItemActive()
    {
        EntityAI ent = GetFocusedItem();
        return ent && !IsItemWithQuantityActive() && !IsItemWithContainerActive();
    }
    
    bool IsEmptyItemActive()
    {
        EntityAI ent = GetFocusedItem();
        return ent == null;
    }
    
    //TODO MW Adjust this
    override bool IsDisplayable()
    {
        return true;
    } 
    
    bool IsTakeable()
    {
        EntityAI ent = GetFocusedItem();
        return ent.IsTakeable();
    }
    
    override bool CanCombineAmmo()
    {
        PlayerBase m_player = PlayerBase.Cast( GetGame().GetPlayer() );
        ItemBase ent = ItemBase.Cast(  GetFocusedItem() );
        ItemBase item_in_hands = ItemBase.Cast( GetGame().GetPlayer().GetHumanInventory().GetEntityInHands() );
        ActionManagerClient amc;
        Class.CastTo(amc, m_player.GetActionManager());
 
        return ( amc.CanPerformActionFromInventory( item_in_hands, ent ) || amc.CanSetActionFromInventory( item_in_hands, ent ) );
    }
    
    override bool EquipItem()
    {
        if (CanEquip())
        {   
            EntityAI ent = GetFocusedItem();
            bool res = false;
            
            if( ent && !ent.IsInherited( Magazine ))
            {
                res = GetGame().GetPlayer().PredictiveTakeOrSwapAttachment( ent );
                if(!res)
                {
                    res = GetGame().GetPlayer().GetInventory().TakeEntityToInventory(InventoryMode.JUNCTURE,FindInventoryLocationType.ATTACHMENT,ent);
                }
            }
            return res;
        }
        return false;
    }
    
    override bool InspectItem()
    {
        EntityAI ent = GetFocusedItem();
        
        if( ent )
        {
            InspectItem( ent );
            return true;
        }
        return false;
    }
        
    override bool TransferItem()
    {
        if (CanTakeToInventory())
        {
            ItemBase ent = ItemBase.Cast(GetFocusedItem());
            if (ent)
            {
                if (ent.IsTakeable())
                {
                    InventoryLocation il = new InventoryLocation;
                    GetGame().GetPlayer().GetInventory().FindFreeLocationFor( ent, FindInventoryLocationType.CARGO, il );
                    if (il.IsValid() && GetGame().GetPlayer().GetInventory().LocationCanAddEntity( il ))
                    {
                        SplitItemUtils.TakeOrSplitToInventoryLocation( PlayerBase.Cast( GetGame().GetPlayer() ), il );
                        return true;
                    }
                }
            }
        }
        return false;
    }
    
    override bool Combine()
    {
        ItemBase ent = ItemBase.Cast( GetFocusedItem() );
        
        ItemBase item_in_hands = ItemBase.Cast( GetGame().GetPlayer().GetHumanInventory().GetEntityInHands() );
        
        Icon hands_icon = ItemManager.GetInstance().GetHandsPreview().GetIcon();
        
        if( item_in_hands && ent && hands_icon )
        {
            return hands_icon.CombineItems( item_in_hands, ent );
        }
        return false;
    }
    
    override bool Select()
    {
        SlotsIcon selected_slot = ItemManager.GetInstance().GetSelectedIcon();
        EntityAI ent = GetFocusedItem();
        ItemBase selected_item = ItemBase.Cast(ItemManager.GetInstance().GetSelectedItem());
        
        if( !(selected_slot && selected_slot.IsOutOfReach() ) )
        {
            if( selected_item )
            {
                if( ent != selected_item)
                {
                    if( selected_item && GetGame().GetPlayer().CanDropEntity( selected_item ) )
                    {
                        bool draggable = false;
        
                        PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
                        draggable = !player.GetInventory().HasInventoryReservation( selected_item, null ) && !player.IsItemsToDelete();
                        draggable = draggable && selected_item.GetInventory().CanRemoveEntity();
                        
                        if( draggable && m_ShowedItems.Find( selected_item ) == -1 )
                        {
                            if( selected_item.GetTargetQuantityMax() < selected_item.GetQuantity() )
                                selected_item.SplitIntoStackMaxClient( null, -1 );
                            else
                                player.PhysicalPredictiveDropItem( selected_item );
                            ItemManager.GetInstance().SetSelectedItemEx(null, null, null);
                            return true;
                        }
                    }
                }
            }
            else
            {
                if( ent && ent.GetInventory().CanRemoveEntity())
                {
                    EntityAI item_in_hands = GetGame().GetPlayer().GetHumanInventory().GetEntityInHands();
                    if( item_in_hands )
                    {
                        if( GameInventory.CanSwapEntitiesEx( item_in_hands, ent ) )
                        {
                            GetGame().GetPlayer().PredictiveSwapEntities( item_in_hands, ent );
                            return true;
                        }
                    }
                    else
                    {
                        if( GetGame().GetPlayer().GetHumanInventory().CanAddEntityInHands( ent ) )
                        {
                            GetGame().GetPlayer().PredictiveTakeEntityToHands( ent );
                            return true;
                        }
                    }
                }
            }
        }
 
        return false;
    }
    
    void ~VicinitySlotsContainer()
    {
        for ( int i = 0; i < m_Container.Count(); i++ )
        {
            Container c = ClosableContainer.Cast( m_Container.Get( i / ITEMS_IN_ROW ) );
            if( c && c.GetMainWidget() )
            {
                delete m_Container.Get( i / ITEMS_IN_ROW ).GetMainWidget();
            }
        }
    }
 
    override void SetLayoutName()
    {
        m_LayoutName = WidgetLayoutName.Container;
    }
 
    override void OnShow()
    {
        super.OnShow();
    }
    
    int GetRowSlotCount()
    {
        return GetFocusedContainer().GetColumnCount();
    }
    
    bool ExcludeFromContainer (EntityAI item)
    {
        int mask = item.GetHideIconMask();
        return mask & EInventoryIconVisibility.HIDE_VICINITY;
    }
    
    void ShowItemsInContainers( array<EntityAI> items )
    {
        EntityAI item;
        SlotsIcon icon;
        int x;
        int visible_items_count = 0;
        int visible_rows = 0;
        ref array<EntityAI> visible_items = new array<EntityAI>;
        
        for ( x = 0; x < items.Count(); ++x )
        {
            item = items.Get( x );
            
            if ( item == null || ExcludeFromContainer(item) )
                continue;
 
            visible_items.Insert( item );
            visible_items_count++;
        }
        
        RecomputeNumberOfContainers( visible_items );
        
        for ( x = 0; x < visible_items_count; ++x )
        {
            item            = visible_items.Get( x );
            int row         = (int)Math.Floor( x / ITEMS_IN_ROW );
            int column      = x % ITEMS_IN_ROW;
            icon            = SlotsContainer.Cast( m_Container.Get( row ) ).GetSlotIcon( column );
            
            icon.GetMainWidget().Show( true );
            icon.GetPanelWidget().SetUserID( item.GetID() );
            
            if ( m_ShowedItems.Find( item ) != x )
                icon.Init( item );
            icon.UpdateInterval();
            
            if ( !ItemManager.GetInstance().IsDragging() )
            {
                ItemManager.GetInstance().SetTemperature( item, icon.GetRender() );
            }
            
            bool draggable = ItemManager.GetInstance().EvaluateContainerDragabilityDefault(item);
            if ( !draggable && GetDragWidget() == icon.GetPanelWidget() )
                CancelWidgetDragging();
            ItemManager.GetInstance().SetWidgetDraggable( icon.GetPanelWidget(), draggable );
 
            ref map<int, ref Container> showed_items = ( VicinityContainer.Cast( m_Parent ) ).m_ShowedItemsIDs;
            
            Container conta = Container.Cast( showed_items.Get( item.GetID() ) );
            if ( conta )
            {
                conta.SetSlotIcon(icon);
            }
            
            if ( conta && conta.IsDisplayable() )
            {
                conta.UpdateRadialIcon();
            }
            else
            {
                icon.GetRadialIconPanel().Show( false );
                if ( conta )
                    conta.OnHide();
            }
        }
        
        SlotsContainer slots_last = SlotsContainer.Cast( m_Container.Get( visible_items.Count() / ITEMS_IN_ROW ) );
        
        for ( int c = visible_items_count % ITEMS_IN_ROW; c < ITEMS_IN_ROW; ++c )
        {
            icon = slots_last.GetSlotIcon( c );
            icon.GetMainWidget().Show( false );
            icon.Clear();
        }
        
        //#ifndef PLATFORM_CONSOLE
        if ( visible_items_count % ITEMS_IN_ROW == 0 )
        {
            slots_last = SlotsContainer.Cast( m_Container.Get( m_Container.Count() - 1 ) );
            slots_last.GetSlotIcon( 0 ).GetMainWidget().Show( true );
            slots_last.GetSlotIcon( 0 ).GetGhostSlot().Show( false );
            slots_last.GetMainWidget().Update();
        }
        //#endif
        
        m_ShowedItems = visible_items;
    }
    
    void DoubleClick(Widget w, int x, int y, int button)
    {
        if( button == MouseState.LEFT && !g_Game.IsLeftCtrlDown())
        {
            if( w == null )
            {
                return;
            }
            ItemPreviewWidget iw = ItemPreviewWidget.Cast( w.FindAnyWidget( "Render" ) );
            if( !iw )
            {
              string name = w.GetName();
              name.Replace( "PanelWidget", "Render" );
              iw = ItemPreviewWidget.Cast( w.FindAnyWidget( name ) );
            } 
            
            if( !iw )
            {
              iw = ItemPreviewWidget.Cast( w );
            }
            
            ItemBase item = ItemBase.Cast( iw.GetItem() );
            if( !item )
            {
                return;
            }
            
            if( !item.IsTakeable() )
            {
                return;
            }
            
            if( GetGame().GetPlayer().GetInventory().HasInventoryReservation( item, null ) )
            {
                return;
            }
            
            if( !item.GetInventory().CanRemoveEntity() )
                return;
            
            PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
                    
            if ( player.GetInventory().HasEntityInInventory( item ) && GetGame().GetPlayer().GetHumanInventory().CanAddEntityInHands( item ) )
            {
                player.PredictiveTakeEntityToHands( item );
            }
            else
            {
                InventoryLocation dst = new InventoryLocation;
                player.GetInventory().FindFreeLocationFor( item, FindInventoryLocationType.ANY, dst );
                if( dst.IsValid() && player.GetInventory().LocationCanAddEntity( dst ) )
                {
                    SplitItemUtils.TakeOrSplitToInventoryLocation( player, dst );
                }
            }
            
            HideOwnedTooltip();
            InventoryMenu menu = InventoryMenu.Cast( GetGame().GetUIManager().FindMenu( MENU_INVENTORY ) );
            if( menu )
            {
                menu.RefreshQuickbar();
            }
        }
    }
    
    string GetItemQuantityText( EntityAI item )
    {
        string quantity_text = "";
        if ( item.IsInherited( InventoryItem ) )
        {
            ItemBase item_base = ItemBase.Cast( item );
            float quantity = item_base.GetQuantity();
            int ammo;
            if ( item.IsInherited( Magazine ) )
            {
                Magazine magazine_item = Magazine.Cast( item );
                ammo = magazine_item.GetAmmoCount();
                quantity_text = ammo.ToString();
                return quantity_text;
            }
            else if ( item.IsInherited( ItemBook ) )
            {
                return "";
            }
            int max = item.GetQuantityMax();
            //string unit = item.ConfigGetString( "stackedUnit" );
 
            if ( max > 0 )
            {
                if ( max == 1 )
                {
                    float tmp = Math.Round( ( quantity / max ) * 100 );
                    quantity_text = tmp.ToString() + "%";
                }
                else
                {
                    quantity_text = quantity.ToString();
                }
            }
        }
        return quantity_text;
    }
    
    int HasItemQuantity( EntityAI item )
    {
        if ( item.IsInherited( InventoryItem ) )
        {
            ItemBase item_base = ItemBase.Cast( item );
            if ( item.IsInherited( Magazine ) )
            {
                return QUANTITY_COUNT;
            }
            else if ( item.IsInherited( ItemBook ) )
            {
                return QUANTITY_HIDDEN;
            }
            int max = item.GetQuantityMax();
            bool bar = item.ConfigGetBool( "quantityBar" );
            if ( max > 0 )
            {
                if ( max == 1 || bar )
                {
                    return QUANTITY_PROGRESS;
                }
                else
                {
                    return QUANTITY_COUNT;
                }
            }
        }
        return QUANTITY_HIDDEN;
    }
    
    float GetItemQuantity( InventoryItem item )
    {
        float quantity = 0;
        if ( item.IsInherited( InventoryItem ) )
        {
            ItemBase item_base = ItemBase.Cast( item );
            if ( item.IsInherited( Magazine ) )
            {
                Magazine magazine_item = Magazine.Cast( item );
                quantity = magazine_item.GetAmmoCount();
            }
            else
            {
                quantity = item_base.GetQuantity();
            }
        }
        return quantity;
    }
    
    // Mouse button DOWN
    void MouseButtonDown( Widget w, int x, int y, int button)
    {
        string name = w.GetName();
        name.Replace( "PanelWidget", "Render" );
        ItemPreviewWidget item_preview = ItemPreviewWidget.Cast( w.FindAnyWidget( name ) );
        ItemBase item = ItemBase.Cast( item_preview.GetItem() );
        bool draggable = ItemManager.GetInstance().EvaluateContainerDragabilityDefault(item);
        ItemManager.GetInstance().SetWidgetDraggable( w, draggable );
    }
    
    // Mouse button UP <---- exist button down MouseButtonDown ^
    void MouseClick( Widget w, int x, int y, int button)
    {
        string name = w.GetName();
        name.Replace( "PanelWidget", "Render" );
        ItemPreviewWidget item_preview = ItemPreviewWidget.Cast( w.FindAnyWidget( name ) );
        EntityAI item = item_preview.GetItem();
        InventoryItem itemAtPos = InventoryItem.Cast( item );
        Container conta;
        
        #ifdef DIAG_DEVELOPER
        if ( ItemBase.Cast(item) )
        {
            if ( GetDayZGame().IsLeftCtrlDown() && button == MouseState.RIGHT )
                ShowActionMenu( ItemBase.Cast(item) );
        }
        #endif
        
        if( m_Parent )
        {
            ref map<int, ref Container> showed_items = ( VicinityContainer.Cast( m_Parent ) ).m_ShowedItemsIDs;
            
            if( item && showed_items )
            {
                conta = showed_items.Get( item.GetID() );
                
                ( VicinityContainer.Cast( m_Parent ) ).ToggleContainer( w, item );
                if ( button == MouseState.RIGHT )
                {
                    if ( itemAtPos )
                    {
                        itemAtPos.OnRightClick();
                    }
                }
                else if ( button == MouseState.MIDDLE )
                {
                    InspectItem( itemAtPos );
                    return;
                }
            }
        }
    }
    
    override void OnDropReceivedFromHeader( Widget w, int x, int y, Widget receiver )
    {
        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.IsInherited( ItemPreviewWidget ) )
        {
            return; 
        }
        
        PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
        ItemBase item = ItemBase.Cast(ipw.GetItem());
        
        if( item )
        {
            if( !item.GetInventory().CanRemoveEntity() )
                return;
            
            if( player.CanDropEntity( item ) )
            {
                if( item.GetTargetQuantityMax() < item.GetQuantity() )
                    item.SplitIntoStackMaxClient( null, -1 );
                else
                    player.PhysicalPredictiveDropItem( item );
            }
        }
    }
    
    void RecomputeNumberOfContainers( array<EntityAI> items )
    {
        int number_of_containers = m_Container.m_Body.Count();
        int number_of_containers_needed = ( items.Count() / ITEMS_IN_ROW ) + 1;
        int difference = number_of_containers_needed - number_of_containers;
        int g;
 
        for (g = number_of_containers; g < number_of_containers_needed; g++)
        {
            SlotsContainer con = new SlotsContainer( m_Container, null );
            m_Container.Insert(con, -1, false);
            for (int j = 0; j < ITEMS_IN_ROW; j++)
            {
                SlotsIcon icon = con.GetSlotIcon(j);
                WidgetEventHandler.GetInstance().RegisterOnDropReceived(icon.GetPanelWidget(),  m_Parent, "OnDropReceivedFromIcon");
                WidgetEventHandler.GetInstance().RegisterOnDropReceived(icon.GetGhostSlot(),  m_Parent, "OnDropReceivedFromHeader");
                WidgetEventHandler.GetInstance().RegisterOnDropReceived(icon.GetMainWidget(),  m_Parent, "OnDropReceivedFromHeader");
                        
                WidgetEventHandler.GetInstance().RegisterOnDraggingOver(icon.GetPanelWidget(),  m_Parent, "DraggingOverIcon");
                WidgetEventHandler.GetInstance().RegisterOnDraggingOver(icon.GetGhostSlot(),  m_Parent, "DraggingOverHeader");
                WidgetEventHandler.GetInstance().RegisterOnDraggingOver(icon.GetMainWidget(),  m_Parent, "DraggingOverHeader");
                        
                WidgetEventHandler.GetInstance().RegisterOnDoubleClick(icon.GetPanelWidget(),  this, "DoubleClick");
                WidgetEventHandler.GetInstance().RegisterOnMouseButtonUp(icon.GetPanelWidget(),  this, "MouseClick");
                WidgetEventHandler.GetInstance().RegisterOnMouseButtonDown(icon.GetPanelWidget(),  this, "MouseButtonDown");
            }
                    
            con.SetColumnCount(items.Count() % ITEMS_IN_ROW);
        }   
 
        for (g = number_of_containers - 1 ; g >= number_of_containers_needed ; g--)
        {
            Widget w = m_Container.m_Body.Get(g).GetMainWidget();
            delete w;
            m_Container.m_Body.Remove(g);
        }
        
        if ( (items.Count() % ITEMS_IN_ROW) == 0 )
        {
            SlotsContainer.Cast( m_Container.Get( number_of_containers_needed - 1 ) ).SetColumnCount( ITEMS_IN_ROW );
        }
        else
        {
            SlotsContainer.Cast( m_Container.Get( number_of_containers_needed - 1 ) ).SetColumnCount( items.Count() % ITEMS_IN_ROW );
        }
        
        for ( int i = 0; i < number_of_containers_needed - 1; i++ )
        {
            SlotsContainer.Cast( m_Container.Get( i ) ).SetColumnCount( ITEMS_IN_ROW );
        }
        
        RecomputeOpenedContainers();
        m_Container.RecomputeOpenedContainers();
    }
}