containerwithcargo.c

Go to the documentation of this file.

class ContainerWithCargo extends ClosableContainer
{
    protected ref CargoContainer    m_CargoGrid;
    protected int m_CargoIndex = -1;
 
    void ContainerWithCargo( Container parent, int sort = -1 )
    {
        m_LockCargo = false;
        m_Parent = parent;
 
        m_CargoGrid = new CargoContainer( this );
        Insert( m_CargoGrid );
        
        m_CargoGrid.GetRootWidget().SetSort( 1 );
        
        WidgetEventHandler.GetInstance().RegisterOnDraggingOver( m_MainWidget,  this, "DraggingOverGrid" );
        RecomputeOpenedContainers();
    }
 
    override bool IsDisplayable()
    {
        if (m_Entity)
            return m_Entity.CanDisplayCargo();
        return false;
    }
    
    override bool IsEmpty()
    {
        return m_CargoGrid.IsEmpty();
    }
    
    override bool IsItemActive()
    {
        return m_CargoGrid.IsItemActive();
    }
    
    override bool CanCombine()
    {
        return m_CargoGrid.CanCombine();
    }
    
    override bool CanCombineAmmo()
    {
        return m_CargoGrid.CanCombineAmmo();
    }
    
    override bool IsItemWithQuantityActive()
    {
        return m_CargoGrid.IsItemWithQuantityActive();
    }
    
    void LockCargo(bool value)
    {
        if( value != m_LockCargo )
        {
            if( value )
            {
                m_LockCargo = true;
                OnHide();
            }
            else
            {
                m_LockCargo = false;
                SetOpenState(!m_Closed);
            }
        }   
    }
    
    override void Open()
    {
        if( !m_LockCargo )
        {
            ItemManager.GetInstance().SetDefaultOpenState( m_Entity.GetType(), true );
            m_Closed = false;
            SetOpenForSlotIcon(true);
            OnShow();
            m_Parent.m_Parent.Refresh();
        }
        
        if ( m_SlotIcon )
        {
            m_SlotIcon.GetRadialIconPanel().Show( !m_LockCargo );
        }
    }
    
    override void Close()
    {
        if( !m_LockCargo )
        {
            ItemManager.GetInstance().SetDefaultOpenState( m_Entity.GetType(), false );
            m_Closed = true;
            SetOpenForSlotIcon(false);
            OnHide();
            m_Parent.m_Parent.Refresh();
        }
        
        if ( m_SlotIcon )
        {
            m_SlotIcon.GetRadialIconPanel().Show( !m_LockCargo );
        }
    }
    
    override bool IsOpened()
    {
        return !m_Closed && !m_LockCargo;
    }
    
    override void UpdateInterval()
    {
        if ( m_Entity )
        {
            if ( m_Entity.GetInventory().IsInventoryLockedForLockType( HIDE_INV_FROM_SCRIPT ) || !m_Entity.CanDisplayCargo()  )
            {
                LockCargo(true);
                if ( m_CargoGrid.IsVisible() )
                {
                    RecomputeOpenedContainers();
                }
            }
            else
            {
                LockCargo(false);
                if ( !m_CargoGrid.IsVisible() )
                {
                    RecomputeOpenedContainers();
                }
            }
        
            super.UpdateInterval();
            m_CargoGrid.UpdateInterval();
            
            bool hide = m_LockCargo || ItemManager.GetInstance().GetDraggedItem() == m_Entity;
            if (!hide)
            {
                SetOpenForSlotIcon(IsOpened());
            }
            
            if ( m_SlotIcon )
            {
                m_SlotIcon.GetRadialIconPanel().Show( !hide );
            }
        }
    }
    
    override bool IsFirstContainerFocused()
    {
        return m_CargoGrid.IsFirstContainerFocused();
    }
    
    override bool IsLastContainerFocused()
    {
        return m_CargoGrid.IsLastContainerFocused();
    }
 
    override void SetDefaultFocus( bool while_micromanagment_mode = false )
    {
        m_CargoGrid.SetDefaultFocus( while_micromanagment_mode );
    }
    
    override void UnfocusAll()
    {
        m_CargoGrid.Unfocus();
    }
    
    override bool SplitItem()
    {
        return m_CargoGrid.SplitItem();
    }
    
    override bool EquipItem()
    {
        return m_CargoGrid.EquipItem();
    }
    
    override bool TransferItem()
    {
        return m_CargoGrid.TransferItem();
    }
    
    override bool TransferItemToVicinity()
    {
        return m_CargoGrid.TransferItemToVicinity();
    }
    
    override bool InspectItem()
    {
        return m_CargoGrid.InspectItem();
    }
 
    void SetEntity( EntityAI entity, int cargo_index = 0, bool immedUpdate = true )
    {
        m_Entity = entity;
        m_CargoIndex = cargo_index;
 
        SetOpenState( true );
 
        m_CargoGrid.SetEntity( entity, immedUpdate );
        m_CargoGrid.UpdateHeaderText();
        m_ClosableHeader.SetItemPreview( entity );
        CheckHeaderDragability();
        ( Container.Cast( m_Parent ) ).Insert( this, -1, false );
        
        if ( m_Entity.GetInventory().IsInventoryLockedForLockType( HIDE_INV_FROM_SCRIPT ) || !m_Entity.CanDisplayCargo() )
            LockCargo(true);
        else
            LockCargo(false);
 
        if ( immedUpdate )
        {
            Refresh();
            GetMainWidget().Update();
        }
    }
 
    EntityAI GetEntity()
    {
        return m_Entity;
    }
    
    override EntityAI GetFocusedContainerEntity()
    {
        return m_Entity;
    }
 
    EntityAI GetItemPreviewItem( Widget 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 || !ipw.IsInherited( ItemPreviewWidget ) )
        {
            return null;
        }
        return ipw.GetItem();
    }
 
    bool DraggingOverGrid( Widget w, int x, int y, Widget reciever )
    {
        if( w == null )
        {
            return false;
        }
        
        PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
        if( !player.CanManipulateInventory() )
        {
            return false;
        }
        
        EntityAI item = GetItemPreviewItem( w );
        
        if( !item )
        {
            return false;
        }
        
        if( !item.GetInventory().CanRemoveEntity() )
        {
            return false;
        } 
 
        int color, c_x, c_y;
        
        #ifdef PLATFORM_CONSOLE
        int idx = -1;
        #else
        int idx = 0;
        #endif
        
        CargoBase cargo = m_Entity.GetInventory().GetCargoFromIndex(m_CargoIndex);
        if( cargo )
        {
            c_x = cargo.GetHeight();
            c_y = cargo.GetWidth();
        }
        
        InventoryLocation dst = new InventoryLocation;
        #ifdef PLATFORM_CONSOLE
        x = 0;
        y = cargo.GetItemCount();
        m_Entity.GetInventory().FindFreeLocationFor( item, FindInventoryLocationType.CARGO, dst );
        #else
        dst.SetCargoAuto(cargo, item, x, y, item.GetInventory().GetFlipCargo());
        #endif
        
        #ifdef PLATFORM_CONSOLE
        if( dst.IsValid() && m_Entity.GetInventory().LocationCanAddEntityEx(dst))
        #else
        if( m_Entity && c_x > x && c_y > y && m_Entity.GetInventory().LocationCanAddEntityEx(dst))
        #endif
        {
            ItemManager.GetInstance().HideDropzones();
            if( m_Entity.GetHierarchyRootPlayer() == GetGame().GetPlayer() )
            {
                ItemManager.GetInstance().GetRightDropzone().SetAlpha( 1 );
            }
            else
            {
                ItemManager.GetInstance().GetLeftDropzone().SetAlpha( 1 );
            }
            color = ColorManager.GREEN_COLOR;
        }
        else
        {
            color = ColorManager.RED_COLOR;
            ItemManager.GetInstance().ShowSourceDropzone( item );
        }
 
        if( w.FindAnyWidget("Cursor") )
        {
            w.FindAnyWidget("Cursor").SetColor( color );
        }
        else
        {
            string name = w.GetName();
            name.Replace( "PanelWidget", "Cursor" );
            if( w.FindAnyWidget( name ) )
            {
                w.FindAnyWidget( name ).SetColor( color );
            }
        }
 
        return true;
    }
 
    void DropReceived( Widget w, int x, int y )
    {
        float xx, yy;
        GetMainWidget().Update();
        GetMainWidget().GetScreenSize( xx, yy );
        if( GetMainWidget().FindAnyWidget("Background") )
        {
            GetMainWidget().FindAnyWidget("Background").Show( true );
            GetMainWidget().FindAnyWidget("Background").SetSize( xx, yy );
        }
        EntityAI item = GetItemPreviewItem( w );
        if( !item )
        {
            return;
        }
        
        #ifdef PLATFORM_CONSOLE
        if( m_CargoGrid.HasItem( item ) )
        {
            return;
        }
        #endif
        
        #ifdef PLATFORM_CONSOLE
        int idx = -1;
        #else
        int idx = 0;
        #endif
        int c_x, c_y;
        
        CargoBase cargo = m_Entity.GetInventory().GetCargoFromIndex(m_CargoIndex);
        
        if( cargo )
        {
            c_x = cargo.GetHeight();
            c_y = cargo.GetWidth();
        }
        
        InventoryLocation dst = new InventoryLocation;
        #ifdef PLATFORM_CONSOLE
        x = 0;
        y = cargo.GetItemCount();
        m_Entity.GetInventory().FindFreeLocationFor( item, FindInventoryLocationType.CARGO, dst );
        #else
        dst.SetCargoAuto(cargo, item, x, y, item.GetInventory().GetFlipCargo());
        #endif
        
        InventoryLocation src = new InventoryLocation;
        item.GetInventory().GetCurrentInventoryLocation(src);
 
        if(src.CompareLocationOnly(dst) && src.GetFlip() == dst.GetFlip())
            return;
        
        #ifdef PLATFORM_CONSOLE
        if(dst.IsValid() && m_Entity.GetInventory().LocationCanAddEntityEx(dst))
        #else
        if( c_x > x && c_y > y && m_Entity.GetInventory().LocationCanAddEntityEx(dst))
        #endif
        {
            PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
            
            SplitItemUtils.TakeOrSplitToInventoryLocation( player, dst );
            
            Icon icon = m_CargoGrid.GetIcon( item );
            
            if( icon && w && w.FindAnyWidget("Cursor") )
            {
                w.FindAnyWidget("Cursor").SetColor( ColorManager.BASE_COLOR );
                icon.Refresh();
                Refresh();
            }
        }
        
        ItemManager.GetInstance().HideDropzones();
        ItemManager.GetInstance().SetIsDragging( false );
    }
    
    void TakeIntoHands( notnull PlayerBase player, notnull EntityAI item )
    {
        ItemBase item_base = ItemBase.Cast( item );
        
        if( !item.GetInventory().CanRemoveEntity() || !player.CanManipulateInventory() )
            return;
        
        float stackable = item_base.GetTargetQuantityMax();
        
        if( stackable == 0 || stackable >= item_base.GetQuantity() )
        {
            player.PredictiveTakeEntityToHands( item );
        }
        else if( stackable != 0 && stackable < item_base.GetQuantity() )
        {
            item_base.SplitIntoStackMaxHandsClient( player );
        }
    }
 
    override void DraggingOverHeader( Widget w, int x, int y, Widget receiver )
    {
        DraggingOver( w, x, y, receiver );
    }
 
    override void DraggingOver( Widget w, int x, int y, Widget receiver )
    {
        if( !w )
            return;
        EntityAI item = GetItemPreviewItem( w );
        if( !item )
            return;
        
        PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
        if( item.GetInventory().CanRemoveEntity() && player.CanManipulateInventory() && m_Entity.GetInventory().CanAddEntityInCargo( item, item.GetInventory().GetFlipCargo() ) && !m_Entity.GetInventory().HasEntityInCargo( item ) )
        {
            ColorManager.GetInstance().SetColor( w, ColorManager.GREEN_COLOR );
            ItemManager.GetInstance().HideDropzones();
            if( m_Entity.GetHierarchyRootPlayer() == GetGame().GetPlayer() )
            {
                ItemManager.GetInstance().GetRightDropzone().SetAlpha( 1 );
            }
            else
            {
                ItemManager.GetInstance().GetLeftDropzone().SetAlpha( 1 );
            }
        }
        else
        {
            ColorManager.GetInstance().SetColor( w, ColorManager.RED_COLOR );
            ItemManager.GetInstance().ShowSourceDropzone( item );
        }
    }
 
    override void OnDropReceivedFromHeader( Widget w, int x, int y, Widget receiver )
    {
        EntityAI item = GetItemPreviewItem( w );
        if( !item )
        {
            return;
        }
 
        PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
        InventoryLocation src = new InventoryLocation();
        if( GetEntity() && item.GetInventory().GetCurrentInventoryLocation(src))
        {
            InventoryLocation dst = new InventoryLocation();
            if (m_Entity.GetInventory().FindFreeLocationFor(item, FindInventoryLocationType.ATTACHMENT, dst))
            {
                player.PredictiveTakeToDst(src, dst);
            }
 
            bool can_add = m_Entity.GetInventory().CanAddEntityInCargo( item, item.GetInventory().GetFlipCargo() );
            bool in_cargo = !player.GetInventory().HasEntityInInventory( item ) || !m_Entity.GetInventory().HasEntityInCargo( item );
            if( can_add && in_cargo )
            {
                SplitItemUtils.TakeOrSplitToInventory( player, m_Entity, item );
            }
        }
    }
}