itemmanager.c

Go to the documentation of this file.

class ItemManager
{
    private ref static ItemManager      m_Instance;
    protected bool                      m_IsDragging;
    protected EntityAI                  m_HoveredItem;
    protected bool                      m_SlotInfoShown;
    protected EntityAI                  m_DraggedItem;
    protected Icon                      m_DraggedIcon;
    protected ref Widget                m_TooltipWidget;
    protected ref Widget                m_TooltipSlotWidget;
    protected ref Widget                m_TooltipCategoryWidget;
    protected ItemPreviewWidget         m_ItemPreviewWidget;
    protected Widget                    m_RootWidget;
    protected ref map<string, bool>     m_DefautOpenStates;
    protected ref map<string, bool>     m_DefautHeaderOpenStates;
    protected int                       m_HandsDefaultOpenState;
    protected ref Timer                 m_ToolTipTimer;
    protected ref Timer                 m_TooltipSlotTimer;
 
    protected EntityAI                  m_SelectedItem;
    protected Container                 m_SelectedContainer;
    protected Widget                    m_SelectedWidget;
    protected SlotsIcon                 m_SelectedIcon;
    protected LayoutHolder              m_SelectedBaseIcon;
    
    protected HandsPreview              m_HandsPreview;
    
    protected bool                      m_ItemMicromanagmentMode;
    
    protected Widget                    m_LeftDropzone;
    protected Widget                    m_CenterDropzone;
    protected Widget                    m_RightDropzone;
    
    protected int                       m_TooltipPosX;
    protected int                       m_TooltipPosY;
    protected Widget                    m_TooltipSourceWidget; //stored here for tooltip position updates
    
    #ifndef PLATFORM_CONSOLE
    protected const float TOOLTIP_DELAY = 0.25; // in seconds
    #else
    protected const float TOOLTIP_DELAY = 1.5; // in seconds
    #endif
    
    void ItemManager( Widget root )
    {
        m_Instance                  = this;
        m_RootWidget                = root;
        m_DefautOpenStates          = new map<string, bool>;
        m_DefautHeaderOpenStates    = new map<string, bool>;
        m_SlotInfoShown             = false;
        
        #ifdef PLATFORM_CONSOLE
            m_TooltipWidget         = GetGame().GetWorkspace().CreateWidgets("gui/layouts/inventory_new/day_z_inventory_new_tooltip_xbox.layout", root );
            m_TooltipSlotWidget     = GetGame().GetWorkspace().CreateWidgets("gui/layouts/inventory_new/day_z_inventory_new_tooltip_slot_xbox.layout", root );
        #else
            m_TooltipWidget         = GetGame().GetWorkspace().CreateWidgets("gui/layouts/inventory_new/day_z_inventory_new_tooltip.layout", root );
            m_TooltipSlotWidget     = GetGame().GetWorkspace().CreateWidgets("gui/layouts/inventory_new/day_z_inventory_new_tooltip_slot.layout", root );
        #endif
        m_TooltipWidget.Show( false );
        m_TooltipSlotWidget.Show( false );
    }
    
    void SetItemMicromanagmentMode( bool item_micromanagment_mode )
    {
        m_ItemMicromanagmentMode = item_micromanagment_mode;
        Inventory.GetInstance().UpdateConsoleToolbar();
    }
    
    bool IsMicromanagmentMode()
    {
        return m_ItemMicromanagmentMode;
    }
    
    HandsPreview GetHandsPreview()
    {
        return m_HandsPreview;
    }
    
    void SetHandsPreview( HandsPreview hansd_preview )
    {
        m_HandsPreview = hansd_preview;
    }
 
    EntityAI GetSelectedItem()
    {
        return m_SelectedItem;
    }
 
    Container GetSelectedContainer()
    {
        return m_SelectedContainer; 
    }
    
    Widget GetSelectedWidget()
    {
        return m_SelectedWidget;
    }
    
    SlotsIcon GetSelectedIcon()
    {
        return m_SelectedIcon;
    }
 
    void SetSelectedItem( EntityAI selected_item, Container selected_container, Widget selected_widget, SlotsIcon selected_icon )
    {
        m_SelectedItem      = selected_item;
        m_SelectedContainer = selected_container;
        m_SelectedWidget    = selected_widget;
        m_SelectedIcon      = selected_icon;
    }
    
    void SetSelectedItemEx( EntityAI selected_item, Container selected_container, LayoutHolder selected_icon )
    {
        SlotsIcon   sIcon;
        Icon        icon;
        
        m_SelectedItem      = selected_item;
        m_SelectedContainer = selected_container;
        
        if (m_SelectedBaseIcon)
        {
            sIcon   = SlotsIcon.Cast(m_SelectedBaseIcon);
            icon    = Icon.Cast(m_SelectedBaseIcon);
            if (sIcon)
            {
                sIcon.GetMicromanagedPanel().Show(false);
            }
            else if (icon)
            {
                icon.GetMicromanagedPanel().Show(false);
            }
        }
        
        if (selected_icon)
        {
            sIcon   = SlotsIcon.Cast(selected_icon);
            icon    = Icon.Cast(selected_icon);
            
            if (sIcon)
            {
                m_SelectedWidget = sIcon.GetCursorWidget();
                sIcon.GetMicromanagedPanel().Show(true);
            }
            else if (icon)
            {
                m_SelectedWidget = icon.GetCursorWidget();
                icon.GetMicromanagedPanel().Show(true);
            }
        }
        else
        {
            m_SelectedWidget = null;
        }
        m_SelectedBaseIcon      = selected_icon;
    }
 
    void ClearDefaultOpenStates()
    {
        m_DefautOpenStates.Clear();
    }
 
    void ClearDefaultHeaderOpenStates()
    {
        m_DefautHeaderOpenStates.Clear();
    }
 
    void SetDefaultOpenState( string type, bool is_opened )
    {
        m_DefautOpenStates.Set( type, is_opened );
    }
 
    void SetDefaultHeaderOpenState( string type, bool is_opened )
    {
        m_DefautHeaderOpenStates.Set( type, is_opened );
    }
 
    void SetDefaultOpenStateHands( bool is_opened )
    {
        m_HandsDefaultOpenState = is_opened;
        int hands_default_open_state = m_HandsDefaultOpenState; //from bool to int for easier parsing
        GetGame().SetProfileString( "defaultOpenStateHands", hands_default_open_state.ToString() );
        GetGame().SaveProfile();
    }
 
    bool GetDefaultOpenStateHands( )
    {
        string value;
        GetGame().GetProfileString( "defaultOpenStateHands", value );
        m_HandsDefaultOpenState = value.ToInt();
        return m_HandsDefaultOpenState;
    }
 
    void SerializeDefaultHeaderOpenStates()
    {
        TStringArray serialized_types = new TStringArray;
 
        for ( int i = 0; i < m_DefautHeaderOpenStates.Count(); i++ )
        {
            int is_opened = m_DefautHeaderOpenStates.GetElement( i ); //from bool to int for easier parsing
            serialized_types.Insert( m_DefautHeaderOpenStates.GetKey( i ) + "," + is_opened );
        }
 
        if( serialized_types.Count() > 0 )
        {
            GetGame().SetProfileStringList( "defaultHeaderOpenStates", serialized_types );
        }
        GetGame().SaveProfile();
    }
 
    void DeserializeDefaultHeaderOpenStates()
    {
        ClearDefaultHeaderOpenStates();
 
        TStringArray serialized_types = new TStringArray;
        GetGame().GetProfileStringList( "defaultHeaderOpenStates", serialized_types );
 
        for( int i = 0; i < serialized_types.Count(); i++ )
        {
            TStringArray strs = new TStringArray;
            serialized_types.Get( i ).Split( ",", strs );
            bool is_opened = strs.Get( 1 ).ToInt();
            SetDefaultHeaderOpenState( strs.Get( 0 ), is_opened );
        }
    }
 
    void SerializeDefaultOpenStates()
    {
        TStringArray serialized_types = new TStringArray;
 
        for ( int i = 0; i < m_DefautOpenStates.Count(); i++ )
        {
            int is_opened = m_DefautOpenStates.GetElement( i ); //from bool to int for easier parsing
            serialized_types.Insert( m_DefautOpenStates.GetKey( i ) + "," + is_opened );
        }
 
        if( serialized_types.Count() > 0 )
        {
            GetGame().SetProfileStringList( "defaultOpenStates", serialized_types );
        }
        GetGame().SaveProfile();
    }
 
    void DeserializeDefaultOpenStates()
    {
        ClearDefaultOpenStates();
 
        TStringArray serialized_types = new TStringArray;
        GetGame().GetProfileStringList( "defaultOpenStates", serialized_types );
 
        for( int i = 0; i < serialized_types.Count(); i++ )
        {
            TStringArray strs = new TStringArray;
            serialized_types.Get( i ).Split( ",", strs );
            bool is_opened = strs.Get( 1 ).ToInt();
            SetDefaultOpenState( strs.Get( 0 ), is_opened );
        }
    }
 
    bool GetDefaultOpenState( string type )
    {
        if( m_DefautOpenStates.Contains( type ) )
        {
            return m_DefautOpenStates.Get( type );
        }
        else
        {
            return true;
        }
    }
 
    bool GetDefaultHeaderOpenState( string type )
    {
        if( m_DefautHeaderOpenStates.Contains( type ) )
        {
            return m_DefautHeaderOpenStates.Get( type );
        }
        else
        {
            return true;
        }
    }
 
    static ItemManager GetInstance()
    {
        return m_Instance;
    }
 
    void HideDropzones()
    {
        GetRightDropzone().SetAlpha( 0 );
        GetLeftDropzone().SetAlpha( 0 );
        GetCenterDropzone().SetAlpha( 0 );
    }
 
    void ShowSourceDropzone( EntityAI item )
    {
        EntityAI owner = item.GetHierarchyParent();
        PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
        
        if (item == player)
        {
            GetRightDropzone().SetAlpha(1);
        }
        else if (owner && owner != player)
        {
            ShowSourceDropzone(owner);
        }
        else
        {
            InventoryLocation inv_loc_src = new InventoryLocation;
            item.GetInventory().GetCurrentInventoryLocation(inv_loc_src);
            int loc_type = inv_loc_src.GetType();
            HideDropzones();
            if (loc_type == InventoryLocationType.GROUND)
            {
                GetLeftDropzone().SetAlpha(1);
            }
            else if (loc_type == InventoryLocationType.HANDS)
            {
                GetCenterDropzone().SetAlpha(1);
            }
            else
            {
                GetRightDropzone().SetAlpha(1);
            }
        }
    }
 
    Widget GetLeftDropzone()
    {
        if (!m_LeftDropzone)
            m_LeftDropzone  = m_RootWidget.FindAnyWidget("LeftPanel").FindAnyWidget("DropzoneX");
        
        return m_LeftDropzone;
    }
    
    Widget GetRightDropzone()
    {
        if( !m_RightDropzone )
            m_RightDropzone = m_RootWidget.FindAnyWidget("RightPanel").FindAnyWidget("DropzoneX");
        return m_RightDropzone;
    }
    
    Widget GetCenterDropzone()
    {
        if( !m_CenterDropzone )
            m_CenterDropzone = m_RootWidget.FindAnyWidget("HandsPanel").FindAnyWidget("DropzoneX");
        return m_CenterDropzone;
    }
    
    EntityAI GetHoveredItem()
    {
        return m_HoveredItem;
    }
 
    void SetDraggedItem( EntityAI dragged_item )
    {
        m_DraggedItem = dragged_item;
    }
 
    EntityAI GetDraggedItem()
    {
        return m_DraggedItem;
    }
 
    void SetDraggedIcon( Icon dragged_icon )
    {
        m_DraggedIcon = dragged_icon;
    }
 
    Icon GetDraggedIcon()
    {
        return m_DraggedIcon;
    }
 
    void SetIsDragging( bool is_dragging )
    {
        m_IsDragging = is_dragging;
        if( !is_dragging )
        {
            SetDraggedItem( null );
            SetDraggedIcon( null );
        }
    }
 
    bool IsDragging()
    {
        return m_IsDragging;
    }
 
    void HideTooltip()
    {
        m_TooltipWidget.Show( false );
        m_HoveredItem = null;
        delete m_ToolTipTimer;
        
        HideTooltipSlot();
    }
    
    void HideTooltipSlot()
    {
        if ( m_SlotInfoShown )
        {
            m_TooltipSlotWidget.Show( false );
            m_SlotInfoShown = false;
            delete m_TooltipSlotTimer;
        }
    }
 
    static int GetItemHealthColor(int pHealthLevel)
    {
        switch (pHealthLevel)
        {
        case -1:
        break;
        case GameConstants.STATE_PRISTINE:
            return Colors.COLOR_PRISTINE;
        case GameConstants.STATE_WORN:
            return Colors.COLOR_WORN;
        case GameConstants.STATE_DAMAGED:
            return Colors.COLOR_DAMAGED;
        case GameConstants.STATE_BADLY_DAMAGED:
            return Colors.COLOR_BADLY_DAMAGED;
        case GameConstants.STATE_RUINED:
            return Colors.COLOR_RUINED; 
        }
            
        return 0x00FFFFFF;
    }
    
    static int GetItemHealthColor(EntityAI item, string zone = "")
    {
        if (item)
        {
            switch (item.GetHealthLevel(zone))
            {
            case -1:
            break;
            case GameConstants.STATE_PRISTINE:
                return Colors.COLOR_PRISTINE;
            case GameConstants.STATE_WORN:
                return Colors.COLOR_WORN;
            case GameConstants.STATE_DAMAGED:
                return Colors.COLOR_DAMAGED;
            case GameConstants.STATE_BADLY_DAMAGED:
                return Colors.COLOR_BADLY_DAMAGED;
            case GameConstants.STATE_RUINED:
                return Colors.COLOR_RUINED; 
            }
        }
            
        return 0x00FFFFFF;
    }
    
    static int ColorFromFloat( float fraction )
    {
        if( fraction > 1 || fraction < 0 )
            return 0x00FFFFFF;
        else if( fraction > 0.80 )
            return Colors.COLOR_PRISTINE;
        else if( fraction > 0.6 )
            return Colors.COLOR_WORN;
        else if( fraction > 0.4 )
            return Colors.COLOR_DAMAGED;
        else if( fraction > 0.2 )
            return Colors.COLOR_BADLY_DAMAGED;
        else
            return Colors.COLOR_RUINED; 
    }
 
    void SetTemperature(EntityAI item, Widget item_w)
    {
        if ( item_w )
        {
            if ( true/*show_temperature */ )
            {
                if ( item && item.IsInherited( ItemBase ) )
                {
                    int color = ColorManager.GetInstance().GetItemColor( ItemBase.Cast( item ) ); // !!!!!
                    if ( color )
                    {
                        string name = item_w.GetName();
                        name.Replace("Render", "Temperature");
                        Widget temperature_widget = item_w.GetParent().FindAnyWidget( name );
                        if ( color != -1 )
                        {
                            temperature_widget.Show( true );
                            temperature_widget.SetColor( color );
                        }
                        else
                        {
                            temperature_widget.Show( false );
                        }
 
                        temperature_widget.SetAlpha( 0.3 );
                    }
                }
            }
        }
    }
 
    void SetIconTemperature(EntityAI item, Widget item_w)
    {
        if ( item_w )
        {
            if ( item && item.IsInherited( ItemBase ) )
            {
                int color = ColorManager.GetInstance().GetItemColor( ItemBase.Cast( item ) );
 
                if ( color )
                {
                    Widget color_widget = item_w.FindAnyWidget( "Color" );
                    if( color != -1 )
                    {
                        color_widget.SetColor( color );
                    }
                    else
                    {
                        color_widget.SetColor( ColorManager.BASE_COLOR );
                    }
                }
            }
        }
    }
 
    void PrepareTooltip(EntityAI item, int x = 0, int y = 0)
    {
        if( IsDragging() || !item )
        {
            return;
        }
        
        if ( item.IsInherited( InventoryItem ) )
        {
            HideTooltip();
            
            m_HoveredItem = item;
            InspectMenuNew.UpdateItemInfo( m_TooltipWidget, item );
            
            int screen_w, screen_h;
            float w, h;
            GetScreenSize(screen_w, screen_h);
            m_TooltipWidget.GetScreenSize(w,h);
            
            if (x == -1)//set by icon focusing
            {
                x = screen_w/2 - w/2;
                float x1,y1;
                m_RootWidget.FindAnyWidget("InventoryFrameWidget").GetScreenPos(x1,y1); //allign to the same height
                y = y1;
            }
            else if (x == 0 && y == 0 && GetGame().GetInput().IsEnabledMouseAndKeyboardEvenOnServer())
            {
                GetMousePos(x,y);
            }
            
            //minimal edge distance adjustments..
            screen_w -= 10;
            screen_h -= 10;
            
            int rightEdge = x + w;
            if (rightEdge > screen_w)
            {
                x = screen_w - w;
            }
            
            int bottomEdge = y + h;
            if (bottomEdge > screen_h)
            {
                y = screen_h - h;
            }
            
            m_TooltipWidget.SetPos(x, y);
            
            m_ToolTipTimer = new Timer();
            m_ToolTipTimer.Run( TOOLTIP_DELAY, this, "ShowTooltip" );
            
            Widget preview_frame = m_TooltipWidget.FindAnyWidget("ItemFrameWidget");
            if (preview_frame)
            {
                m_ItemPreviewWidget = ItemPreviewWidget.Cast( preview_frame );
                m_ItemPreviewWidget.SetItem(item);
                m_ItemPreviewWidget.SetView( item.GetViewIndex() );
            }
        }
    }
    
    void PrepareSlotsTooltip(string name, string desc, int x = 0, int y = 0)
    {
        InspectMenuNew.UpdateSlotInfo( m_TooltipSlotWidget, name, desc );
        
        HideTooltip();
        
        if (name != "") 
        {
            m_SlotInfoShown = true;
            //CalculateTooltipSlotPosition(x,y);
            m_TooltipSlotTimer = new Timer();
            m_TooltipSlotTimer.Run( TOOLTIP_DELAY, this, "ShowTooltipSlot" );
        }
    }
    
    void CalculateTooltipSlotPosition(int x = 0, int y = 0)
    {
        int screen_w, screen_h;
        float w, h;
        GetScreenSize(screen_w, screen_h);
        //m_TooltipSlotWidget.GetScreenSize(w,h);
        m_TooltipSlotWidget.GetSize(w,h);
        int slot_normal_w = SlotsIcon.GetNormalWidth();
        int slot_normal_h = SlotsIcon.GetNormalHeight();
        //minimal edge distance adjustments..
        screen_w -= 10;
        screen_h -= 10;
        
#ifndef PLATFORM_CONSOLE
        x += 5;
        y += slot_normal_h + 5;
#else
        x += 5;
        y += 15;
#endif
        Widget scrollerWidget = m_TooltipSourceWidget.GetParent();
        while (scrollerWidget)
        {
            if (ScrollWidget.Cast(scrollerWidget))
            {
                break;
            }
            else
            {
                scrollerWidget = scrollerWidget.GetParent();
            }
        }
 
        int rightEdge = x + w;
        if (rightEdge > screen_w)
        {
            x = screen_w - w;
        }
 
        int bottomEdge = y + h;
        if (scrollerWidget)
        {
            float scrollerX, scrollerY, scrollerSizeX, scrollerSizeY;
            scrollerWidget.GetScreenPos(scrollerX,scrollerY);
            scrollerWidget.GetScreenSize(scrollerSizeX,scrollerSizeY);
            
            int scroller_bottom = scrollerY + scrollerSizeY;
            if (bottomEdge > scroller_bottom)
            {
                y = scroller_bottom - slot_normal_h;
                bottomEdge = y + h;
            }
        }
        /*else
        {
            ErrorEx("No scroller widget! | m_TooltipSourceWidget: " + m_TooltipSourceWidget);
        }*/
        
        if (bottomEdge > screen_h) //should mostly never proc now
        {
            y = screen_h - h;
        }
        
        m_TooltipPosX = x;
        m_TooltipPosY = y;
    }
    
    void UpdateTooltipSlotPosition()
    {
        float x, y;
        m_TooltipSourceWidget.GetScreenPos(x,y);
        CalculateTooltipSlotPosition(x,y);
    }
    
    void SetTooltipWidget(Widget w)
    {
        m_TooltipSourceWidget = w;
    }
    
    bool EvaluateContainerDragabilityDefault(EntityAI entity)
    {
        if ( !ItemBase.Cast( entity ) )
            return false;
        
        bool draggable;
        PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer());
        draggable = !player.GetInventory().HasInventoryReservation( entity, null ) && !player.IsItemsToDelete();
        draggable = draggable && entity.CanPutIntoHands( GetGame().GetPlayer() );
        draggable = draggable && entity.GetInventory().CanRemoveEntity();
        
        return draggable;
    }
    
    void SetWidgetDraggable( Widget w, bool draggable )
    {
        if (w)
        {
            if ( draggable )
                w.SetFlags( WidgetFlags.DRAGGABLE );
            else
                w.ClearFlags( WidgetFlags.DRAGGABLE );
        }
    }
    
    void ShowTooltip()
    {   
        if( m_ItemPreviewWidget )
        {
            m_TooltipWidget.Show( true );
        }
    }
    
    void ShowTooltipSlot()
    {   
        UpdateTooltipSlotPosition();
        m_TooltipSlotWidget.SetPos(m_TooltipPosX, m_TooltipPosY);
        m_TooltipSlotWidget.Show( true );
    }
    
    static int GetChosenCombinationFlag( EntityAI selectedEntity, EntityAI targetEntity, int relevantFlags, out InventoryLocation dst = null)
    {
        PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
        
        if (!selectedEntity || !targetEntity)
            return InventoryCombinationFlags.NONE;
        
        ItemBase selectedItem = ItemBase.Cast(selectedEntity);
        ItemBase targetItem = ItemBase.Cast(targetEntity);
        
        //EntityAI itemInHands = m_player.GetHumanInventory().GetEntityInHands();
        ActionManagerClient amc = ActionManagerClient.Cast(player.GetActionManager());
        
        if (relevantFlags & InventoryCombinationFlags.PERFORM_ACTION)
        {
            if (amc.CanPerformActionFromInventory(targetItem, selectedItem))
                return InventoryCombinationFlags.PERFORM_ACTION;
        }
        
        if (relevantFlags & InventoryCombinationFlags.SET_ACTION)
        {
            if (amc.CanSetActionFromInventory(targetItem, selectedItem))
                return InventoryCombinationFlags.SET_ACTION;
        }
        
        if (relevantFlags & InventoryCombinationFlags.COMBINE_QUANTITY2)
        {
            if (targetEntity.CanBeCombined(selectedEntity))
            { 
                return InventoryCombinationFlags.COMBINE_QUANTITY2;
            }
        }
        
        if (relevantFlags & InventoryCombinationFlags.ADD_AS_ATTACHMENT)
        {
            if (targetEntity.GetInventory().CanAddAttachment(selectedEntity))
            {
                return InventoryCombinationFlags.ADD_AS_ATTACHMENT;
            }
        }
        
        if (relevantFlags & InventoryCombinationFlags.ADD_AS_CARGO)
        {
            if (!targetEntity.GetInventory().HasEntityInInventory(selectedEntity) && targetEntity.GetInventory().CanAddEntityInCargo( selectedEntity, selectedEntity.GetInventory().GetFlipCargo() ))
            {
                return InventoryCombinationFlags.ADD_AS_CARGO;
            }
        }
        
        if (relevantFlags & InventoryCombinationFlags.SWAP_MAGAZINE)
        {
            Magazine mag = Magazine.Cast(targetEntity);
            Weapon_Base wpn = Weapon_Base.Cast(targetEntity.GetHierarchyParent());
            if (wpn && mag)
            {
                if (player.GetWeaponManager().CanSwapMagazine(wpn,  Magazine.Cast(selectedEntity)))
                {
                    return InventoryCombinationFlags.SWAP_MAGAZINE;
                }
            }
        }
        
        if (relevantFlags & InventoryCombinationFlags.SWAP)
        {
            if (GameInventory.CanSwapEntitiesEx(selectedEntity, targetEntity))
            {
                return InventoryCombinationFlags.SWAP;
            }
        }
        
        if (relevantFlags & InventoryCombinationFlags.FSWAP)
        {
            if (GameInventory.CanForceSwapEntitiesEx(selectedEntity, null, targetEntity, dst))
            {
                return InventoryCombinationFlags.FSWAP;
            }
        }
        
        return InventoryCombinationFlags.NONE;
    }
    
    static int GetCombinationFlags( EntityAI entity1, EntityAI entity2 )
    {
        int flags = 0;
        PlayerBase m_player = PlayerBase.Cast( GetGame().GetPlayer() );
 
        if (!entity1 || !entity2)
            return flags;
        
        if (entity1.IsInherited( ItemBase ) && entity2.IsInherited( ItemBase ))
        {
            ItemBase ent1 = ItemBase.Cast( entity1 );
            if (ent1.CanBeCombined( ItemBase.Cast( entity2 ) )) flags = flags | InventoryCombinationFlags.COMBINE_QUANTITY2;
        }
 
        if (entity1.GetInventory().CanAddAttachment( entity2 ))
        {
            if (!entity1.IsInherited( ZombieBase ) && !entity1.IsInherited( Car ) && !entity2.IsInherited( ZombieBase ) && !entity2.IsInherited( Car ))
            {
                flags = flags | InventoryCombinationFlags.ADD_AS_ATTACHMENT;
            }
        }
        if (!entity1.GetInventory().HasEntityInInventory(entity2) && entity1.GetInventory().CanAddEntityInCargo( entity2, entity2.GetInventory().GetFlipCargo() )) flags = flags | InventoryCombinationFlags.ADD_AS_CARGO;
 
        if (entity1 == m_player.GetHumanInventory().GetEntityInHands() || entity2 == m_player.GetHumanInventory().GetEntityInHands())
        {
            ActionManagerClient amc;
            Class.CastTo(amc, m_player.GetActionManager());
            if (entity1 == m_player.GetHumanInventory().GetEntityInHands())
            {
                if (amc.CanPerformActionFromInventory( ItemBase.Cast(entity1), ItemBase.Cast(entity2) ))
                {
                    flags = flags | InventoryCombinationFlags.PERFORM_ACTION;
                }
                else if (amc.CanSetActionFromInventory( ItemBase.Cast(entity1), ItemBase.Cast(entity2) ))
                {
                    flags = flags | InventoryCombinationFlags.SET_ACTION;
                }
            }
            else
            {
                if (amc.CanPerformActionFromInventory( ItemBase.Cast(entity2), ItemBase.Cast(entity1) ))
                {
                    flags = flags | InventoryCombinationFlags.PERFORM_ACTION;
                }
                else if (amc.CanSetActionFromInventory( ItemBase.Cast(entity2), ItemBase.Cast(entity1) ))
                {
                    flags = flags | InventoryCombinationFlags.SET_ACTION;
                }
            }
        }
        return flags;
    }
    
    static int GetRecipeCount(bool recipe_anywhere, EntityAI entity1, EntityAI entity2)
    {
        PluginRecipesManager plugin_recipes_manager = PluginRecipesManager.Cast(GetPlugin( PluginRecipesManager ));
        return plugin_recipes_manager.GetValidRecipes( ItemBase.Cast( entity1 ), ItemBase.Cast( entity2 ), NULL, PlayerBase.Cast( GetGame().GetPlayer() ) );
    }
}