vicinitycontainer.c

Go to the documentation of this file.

class VicinityContainer: CollapsibleContainer
{
 ref VicinitySlotsContainer m_VicinityIconsContainer;
 ref map<EntityAI, ref Container> m_ShowedItems = new ref map<EntityAI, ref Container>;
 ref map<int, ref Container> m_ShowedItemsIDs = new ref map<int, ref Container>;
 ref array<EntityAI> m_ShowedItemIcons = new array<EntityAI>;
 ref map<CargoBase, ref Container> m_ShowedCargos = new ref map<CargoBase, ref Container>;
 protected bool m_IsProcessing = false; // Prevents refreshing every time a child is added while it is still processing
 
 const float DISTANCE_TO_ENTITIES = 1.0;
 const float DISTANCE_TO_THE_REST = 0.5;
 
 void VicinityContainer( LayoutHolder parent, int sort = -1 )
 {
 m_VicinityIconsContainer = new VicinitySlotsContainer( this );
 m_Body.Insert( m_VicinityIconsContainer );
 m_VicinityIconsContainer.GetRootWidget().SetColor(166 << 24 | 120 << 16 | 120 << 8 | 120);
 m_MainWidget = m_RootWidget.FindAnyWidget( "body" );
 WidgetEventHandler.GetInstance().RegisterOnChildAdd( m_MainWidget, this, "OnChildAdd" );
 WidgetEventHandler.GetInstance().RegisterOnChildRemove( m_MainWidget, this, "OnChildRemove" );
 
 RecomputeOpenedContainers();
 m_CollapsibleHeader.SetName("#container_vicinity");
 LoadDefaultState();
 }
 
 bool IsVicinityContainerIconsActive()
 {
 return m_VicinityIconsContainer.IsActive();
 }
 
 VicinitySlotsContainer GetVicinityIconsContainer()
 {
 return m_VicinityIconsContainer;
 }
 
 bool IsContainerWithCargoActive()
 {
 return ( ContainerWithCargo.Cast( GetFocusedContainer() ) != null );
 }
 
 bool IsItemWithAttachmentsActive()
 {
 return ( ContainerWithCargoAndAttachments.Cast( GetFocusedContainer() ) != null );
 }
 
 bool IsItemWithCategoriesActive()
 {
 return ( AttachmentCategoriesContainer.Cast( GetFocusedContainer() ) != null );
 }
 
 void TraverseShowedItems()
 {
 map<string, bool> serialized_types = new map<string, bool>();
 for ( int i = 0; i < m_ShowedItems.Count(); i++ )
 {
 EntityAI entity = m_ShowedItems.GetKey( i );
 Container container = m_ShowedItems.GetElement( i );
 string type = entity.GetType();
 if ( container.IsInherited( ContainerWithCargo ) )
 {
 if ( !serialized_types.Contains( type ) )
 {
 ContainerWithCargo item_with_cargo = ContainerWithCargo.Cast( container );
 serialized_types.Insert( type, item_with_cargo.IsOpened() );
 }
 }
 }
 
 if ( serialized_types.Count() > 0 )
 {
 FileSerializer file = new FileSerializer();
 if ( file.Open( "inventory_state.save", FileMode.APPEND ) )
 {
 file.Write( serialized_types.Count() );
 
 for ( i = 0; i < serialized_types.Count(); i++ )
 {
 file.Write( serialized_types.GetKey( i ) );
 file.Write( serialized_types.GetElement( i ) );
 }
 }
 file.Close();
 }
 }
 
 override void DraggingOverHeader( Widget w, int x, int y, Widget receiver )
 {
 if ( w == null )
 {
 return;
 }
 
 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 && ItemPreviewWidget.Cast( w ) )
 {
 ipw = ItemPreviewWidget.Cast( w );
 }
 
 if ( !ipw || !ipw.GetItem() )
 {
 return;
 }
 
 if ( ipw.GetItem() && GetGame().GetPlayer().CanDropEntity( ipw.GetItem() ) && ipw.GetItem().GetInventory().CanRemoveEntity() && m_ShowedItemIcons.Find( ipw.GetItem() ) == -1 )
 {
 ColorManager.GetInstance().SetColor( w, ColorManager.GREEN_COLOR );
 ItemManager.GetInstance().HideDropzones();
 ItemManager.GetInstance().GetLeftDropzone().SetAlpha( 1 );
 }
 else
 {
 ColorManager.GetInstance().SetColor( w, ColorManager.RED_COLOR );
 ItemManager.GetInstance().ShowSourceDropzone( ipw.GetItem() );
 }
 }
 
 void DraggingOverIcon( Widget w, int x, int y, Widget receiver )
 {
 string name = receiver.GetName();
 name.Replace("PanelWidget", "Render");
 ItemPreviewWidget receiver_iw = ItemPreviewWidget.Cast( receiver.FindAnyWidget(name) );
 EntityAI receiver_item = receiver_iw.GetItem();
 
 ItemPreviewWidget ipw = ItemPreviewWidget.Cast( w.FindAnyWidget( "Render" ) );
 if ( !ipw )
 {
 name = w.GetName();
 name.Replace( "PanelWidget", "Render" );
 ipw = ItemPreviewWidget.Cast( w.FindAnyWidget( name ) );
 }
 
 if ( !ipw && ItemPreviewWidget.Cast( w ) )
 {
 ipw = ItemPreviewWidget.Cast( w );
 }
 
 if (!ipw)
 {
 return;
 }
 
 if ( !ItemBase.Cast( receiver_item ) || !ipw.GetItem() )
 {
 return;
 }
 
 if ( ipw.GetItem().GetInventory().CanRemoveEntity() || m_ShowedItemIcons.Find( ipw.GetItem() ) > -1 )
 {
 if ( ( ItemBase.Cast( receiver_item ) ).CanBeCombined( ItemBase.Cast( ipw.GetItem() ) ) )
 {
 ColorManager.GetInstance().SetColor( w, ColorManager.COMBINE_COLOR );
 ItemManager.GetInstance().HideDropzones();
 ItemManager.GetInstance().GetLeftDropzone().SetAlpha( 1 );
 return;
 }
 else if ( GameInventory.CanSwapEntitiesEx( receiver_item, ipw.GetItem() ) )
 {
 ColorManager.GetInstance().SetColor( w, ColorManager.SWAP_COLOR );
 ItemManager.GetInstance().HideDropzones();
 ItemManager.GetInstance().GetLeftDropzone().SetAlpha( 1 );
 return;
 }
 /*else if( GetGame().GetPlayer().CanDropEntity( ipw.GetItem() ) )
 {
 ColorManager.GetInstance().SetColor( w, ColorManager.GREEN_COLOR );
 ItemManager.GetInstance().HideDropzones();
 ItemManager.GetInstance().GetLeftDropzone().SetAlpha( 1 );
 return;
 }*/
 }
 
 ColorManager.GetInstance().SetColor( w, ColorManager.RED_COLOR );
 ItemManager.GetInstance().ShowSourceDropzone( ipw.GetItem() );
 }
 
 void OnDropReceivedFromIcon( Widget w, int x, int y, Widget receiver )
 {
 string name = receiver.GetName();
 name.Replace("PanelWidget", "Render");
 ItemPreviewWidget receiver_iw = ItemPreviewWidget.Cast( receiver.FindAnyWidget(name) );
 EntityAI receiver_item = receiver_iw.GetItem();
 
 ItemPreviewWidget ipw = ItemPreviewWidget.Cast( w.FindAnyWidget( "Render" ) );
 if ( !ipw )
 {
 name = w.GetName();
 name.Replace( "PanelWidget", "Render" );
 ipw = ItemPreviewWidget.Cast( w.FindAnyWidget( name ) );
 }
 
 if ( !ItemBase.Cast( receiver_item ) || !ipw.GetItem() )
 {
 return;
 }
 
 EntityAI item = ipw.GetItem();
 bool equal_typed = item.GetType() == receiver_item.GetType();
 if ( !receiver_item.IsInherited( ItemBase ) || item == null )
 {
 return;
 }
 
 PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
 
 if ( !item.GetInventory().CanRemoveEntity() )
 return;
 
 if ( ( ItemBase.Cast( receiver_item ) ).CanBeCombined( ItemBase.Cast( item ) ) )
 {
 ( ItemBase.Cast( receiver_item ) ).CombineItemsClient( ItemBase.Cast( item ) );
 }
 else if( GameInventory.CanSwapEntitiesEx( receiver_item, item ) )
 {
 InventoryLocation il1 = new InventoryLocation;
 InventoryLocation il2 = new InventoryLocation;
 receiver_item.GetInventory().GetCurrentInventoryLocation( il1 );
 item.GetInventory().GetCurrentInventoryLocation( il2 );
 
 if( !receiver_item.GetInventory().CanRemoveEntity() || ( il1.GetType() == InventoryLocationType.GROUND && il2.GetType() == InventoryLocationType.GROUND ) )
 return;
 player.PredictiveSwapEntities( item, receiver_item );
 }
 
 ItemManager.GetInstance().HideDropzones();
 ItemManager.GetInstance().SetIsDragging( false );
 PrepareOwnedTooltip(item);
 
 InventoryMenu menu = InventoryMenu.Cast( GetGame().GetUIManager().FindMenu( MENU_INVENTORY ) );
 if ( menu )
 {
 menu.RefreshQuickbar();
 }
 }
 
 void OnLeftPanelDropReceived( Widget w, int x, int y, Widget receiver )
 {
 OnDropReceivedFromHeader( w, x, y, receiver );
 }
 
 void OnDropReceivedFromEmptySpace( Widget w, int x, int y, Widget receiver )
 {
 OnDropReceivedFromHeader( w, x, y, receiver );
 }
 
 override void OnDropReceivedFromHeader(Widget w, int x, int y, Widget receiver)
 {
 if (!w)
 return;
 
 ItemManager.GetInstance().HideDropzones();
 ItemManager.GetInstance().SetIsDragging(false);
 
 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 (!ipw.IsInherited(ItemPreviewWidget) || !item)
 return;
 
 if (!item.GetInventory().CanRemoveEntity() || m_ShowedItemIcons.Find(item) > -1)
 return;
 
 PlayerBase player = PlayerBase.Cast(GetGame().GetPlayer()); 
 if (player.CanDropEntity(item))
 {
 ItemBase itemBase = ItemBase.Cast(item);
 if (itemBase)
 {
 if (itemBase.GetTargetQuantityMax() < itemBase.GetQuantity())
 itemBase.SplitIntoStackMaxClient(null, -1);
 else
 player.PhysicalPredictiveDropItem(itemBase);
 }
 }
 
 InventoryMenu menu = InventoryMenu.Cast( GetGame().GetUIManager().FindMenu( MENU_INVENTORY ) );
 if ( menu )
 {
 menu.RefreshQuickbar();
 }
 }
 
 override void UpdateInterval()
 {
 PlayerBase player = PlayerBase.Cast( GetGame().GetPlayer() );
 
 if (!player)
 return;
 
 super.UpdateInterval();
 
 EntityAI eai;
 vector pos = player.GetPosition();
 ref array<EntityAI> objects;
 
 VicinityItemManager.GetInstance().Update( player.GetDeltaT() );
 objects = VicinityItemManager.GetInstance().GetVicinityItems();
 
 //GetItemsShowableInInventory
 array<EntityAI> showable_items = new array<EntityAI>;
 int m_OldShowedItemIconsCount = m_ShowedItemIcons.Count();
 m_ShowedItemIcons.Clear();
 
 GameInventory game_inventory = player.GetInventory();
 for ( int i = 0; i < objects.Count(); i++ )
 {
 eai = objects.Get( i ); 
 if ( eai == null || game_inventory.IsPlaceholderEntity( eai ) )
 continue; // noproxy: ignore body placeholder
 
 BaseBuildingBase base_building = BaseBuildingBase.Cast(eai);
 if (base_building && !base_building.IsPlayerInside(player,""))
 continue;
 
 if ( eai.IsInventoryVisible() )
 {
 showable_items.Insert( eai );
 
 if ( !eai.IsInherited( DayZInfected ) && !eai.IsInherited( PlayerBase ) && !eai.IsInherited( AnimalBase ) && !eai.DisableVicinityIcon() )
 {
 m_ShowedItemIcons.Insert( eai );
 }
 }
 }
 
 
 //MW HOTFIX - old containers must be removed before new one are added (part of initialize are refreshed whole structure - need proper fix to avoid it)
 ref map<EntityAI, ref Container> new_showed_items = new ref map<EntityAI, ref Container>;
 Container con;
 
 for ( i = 0; i < showable_items.Count(); i++ )
 {
 new_showed_items.Insert(showable_items[i],null);
 }
 
 
 bool need_update_focus = false;
 for ( i = 0; i < m_ShowedItems.Count(); i++ )
 {
 EntityAI ent = m_ShowedItems.GetKey( i );
 m_ShowedItems.GetElement( i ).UpdateInterval();
 con = m_ShowedItems.GetElement( i );
 if ( !new_showed_items.Contains( ent ) )
 {
 GetMainWidget().Update();
 if ( con.IsActive() )
 need_update_focus = true;
 Container.Cast( GetParent() ).Remove( con );
 Remove( con );
 }
 else
 {
 UpdateHeader(ent,con,player); //squeezed here, the map is iterated over enough already..
 }
 }
 
 bool accessInventory = PlayerBase.DEBUG_INVENTORY_ACCESS;
 accessInventory |= FreeDebugCamera.GetInstance() && FreeDebugCamera.GetInstance().IsActive();
 
 
 //ref map<EntityAI, ref Container> new_showed_items = new ref map<EntityAI, ref Container>;
 new_showed_items.Clear();
 ref map<int, ref Container> showed_items_IDs = new ref map<int, ref Container>;
 for ( i = 0; i < showable_items.Count(); i++ )
 {
 EntityAI entity = showable_items.Get( i );
 if ( entity )
 {
 if ( game_inventory && !m_ShowedItems.Contains( entity ) )
 {
 string config = "CfgVehicles " + entity.GetType() + " GUIInventoryAttachmentsProps";
 
 if ( GetGame().ConfigIsExisting( config ) )
 {
 AttachmentCategoriesContainer ac = new AttachmentCategoriesContainer( m_Parent, -1 );
 ac.SetEntity( entity );
 new_showed_items.Insert( entity, ac );
 showed_items_IDs.Insert( entity.GetID(), ac);
 }
 else if ( entity.GetSlotsCountCorrect() > 0 && entity.GetInventory().GetCargo() )
 {
 if ( entity.IsInherited( DayZInfected ) )
 {
 if ( entity.IsAlive() )
 {
 continue;
 }
 ZombieContainer zmb_cnt = new ZombieContainer( m_Parent, -1 );
 zmb_cnt.SetEntity( entity );
 new_showed_items.Insert( entity, zmb_cnt );
 showed_items_IDs.Insert( entity.GetID(), zmb_cnt );
 Container.Cast( GetParent() ).Insert( zmb_cnt );
 }
 else
 {
 ContainerWithCargoAndAttachments iwca = new ContainerWithCargoAndAttachments( this, -1 );
 iwca.SetEntity( entity, false );
 new_showed_items.Insert( entity, iwca );
 showed_items_IDs.Insert( entity.GetID(), iwca );
 }
 }
 else if ( entity.GetInventory().GetCargo() )
 {
 ContainerWithCargo iwc = new ContainerWithCargo( this, -1 );
 iwc.SetEntity( entity, 0, false );
 new_showed_items.Insert( entity, iwc );
 showed_items_IDs.Insert( entity.GetID(), iwc );
 iwc.UpdateInterval();
 }
 else if ( entity.GetSlotsCountCorrect() > 0 )
 {
 if ( entity.HasEnergyManager() )
 {
 ContainerWithElectricManager iwem = new ContainerWithElectricManager( this, -1 );
 iwem.SetEntity( entity, false );
 new_showed_items.Insert( entity, iwem );
 showed_items_IDs.Insert( entity.GetID(), iwem );
 }
 else
 {
 if ( entity.IsInherited( PlayerBase ) )
 {
 if (accessInventory == false)
 {
 if ( entity.IsAlive() && ( !PlayerBase.Cast( entity ).IsUnconscious() && !PlayerBase.Cast( entity ).IsRestrained() ) )
 {
 continue;
 }
 }
 
 PlayerContainer plyr_cnt = new PlayerContainer( m_Parent, false );
 plyr_cnt.SetPlayer( PlayerBase.Cast( entity ) );
 Container.Cast( GetParent() ).Insert( plyr_cnt );
 ( Container.Cast( m_Parent ) ).Refresh();
 new_showed_items.Insert( entity, plyr_cnt );
 showed_items_IDs.Insert( entity.GetID(), plyr_cnt);
 }
 else
 {
 ContainerWithCargoAndAttachments iwcas = new ContainerWithCargoAndAttachments( this, -1 );
 iwcas.SetEntity( entity, false );
 new_showed_items.Insert( entity, iwcas );
 showed_items_IDs.Insert( entity.GetID(), iwcas );
 iwcas.UpdateInterval();
 }
 }
 }
 }
 else
 {
 //TODO MW: remove old containers on one spot (hotfix)
 con = m_ShowedItems.Get( entity );
 if ( con )
 {
 if ( entity.IsInherited( PlayerBase ) )
 {
 if ( !accessInventory && entity.IsAlive() && ( !PlayerBase.Cast( entity ).IsUnconscious() && !PlayerBase.Cast( entity ).IsRestrained() ) )
 {
 GetMainWidget().Update();
 if ( con.IsActive() )
 need_update_focus = true;
 Container.Cast( GetParent() ).Remove( con );
 Remove( con );
 continue;
 }
 }
 
 if ( entity.IsInherited( BaseBuildingBase ) )
 { 
 if ( !BaseBuildingBase.Cast(entity).IsPlayerInside(player,""))
 {
 GetMainWidget().Update();
 if ( con.IsActive() )
 need_update_focus = true;
 Container.Cast( GetParent() ).Remove( con );
 Remove( con );
 continue;
 }
 }
 
 new_showed_items.Insert( entity, m_ShowedItems.Get( entity ) );
 showed_items_IDs.Insert( entity.GetID(), m_ShowedItemsIDs.Get( entity.GetID() ) );
 }
 }
 }
 }
 
 ref map<CargoBase, ref Container> new_showed_cargos = new ref map<CargoBase, ref Container>;
 auto cargoes = VicinityItemManager.GetInstance().GetVicinityCargos();
 for ( i = 0; i < cargoes.Count(); i++ )
 {
 CargoBase cgo = cargoes.Get( i );
 if ( cgo )
 {
 if (game_inventory && !m_ShowedCargos.Contains( cgo ) )
 {
 ContainerWithCargo pxc = new ContainerWithCargo( this, -1 );
 pxc.SetEntity( cgo.GetCargoOwner(), cgo.GetOwnerCargoIndex(), false );
 new_showed_cargos.Insert( cgo, pxc );
 pxc.UpdateInterval();
 }
 else
 {
 if ( m_ShowedCargos.Get( cgo ) )
 {
 new_showed_cargos.Insert( cgo, m_ShowedCargos.Get( cgo ) );
 }
 }
 }
 }
 
 for ( int ic = 0; ic < m_ShowedCargos.Count(); ic++ )
 {
 CargoBase cgo2 = m_ShowedCargos.GetKey( ic );
 m_ShowedCargos.GetElement( ic ).UpdateInterval();
 if ( !new_showed_cargos.Contains( cgo2 ) )
 {
 Container con2 = m_ShowedCargos.GetElement( ic );
 if( con2.IsActive() )
 need_update_focus = true;
 GetMainWidget().Update();
 Container.Cast( GetParent() ).Remove( con2 );
 Remove( con2 );
 }
 }
 
 m_ShowedItems = new_showed_items;
 m_ShowedItemsIDs = showed_items_IDs;
 m_ShowedCargos = new_showed_cargos;
 //Because WTF (zombie container)
 Container.Cast( GetParent() ).RecomputeOpenedContainers();
 if (need_update_focus)
 SetFirstActive();
 //RecomputeOpenedContainers();
 UpdateCollapseButtons();
 m_VicinityIconsContainer.ShowItemsInContainers( m_ShowedItemIcons );
 
 if ( m_ShowedItemIcons.Count() != m_OldShowedItemIconsCount )
 {
 Inventory in = Inventory.Cast( GetRoot() );
 if ( in )
 in.UpdateConsoleToolbar(); 
 }
 }
 
 void ToggleContainer( Widget w, EntityAI item )
 {
 SlotsIcon slots_icon;
 Container c;
 w.GetUserData(slots_icon);
 
 if ( item )
 {
 c = Container.Cast( m_ShowedItems.Get( item ) );
 }
 
 if (c)
 {
 ToggleContainer(c);
 }
 }
 
 override bool CanOpenCloseContainerEx(EntityAI focusedEntity)
 {
 if (focusedEntity)
 {
 ClosableContainer c = ClosableContainer.Cast( m_ShowedItems.Get( focusedEntity ) );
 if (c && c.IsDisplayable())
 { 
 return true;
 }
 }
 return false;
 }
 
 //Call from ExpandCollapseContainer - not call
 void ToggleContainer( notnull Container conta )
 {
 conta.Toggle();
 }
 
 override void ExpandCollapseContainer()
 {
 EntityAI item = GetFocusedItem();
 Container conta;
 
 if (m_ShowedItems && item)
 {
 conta = m_ShowedItems.Get( item );
 if (conta)
 { 
 ToggleContainer( conta );
 }
 }
 }
 
 override bool OnChildRemove( Widget w, Widget child )
 {
 w.Update();
 float x, y;
 w.GetScreenSize( x, y );
 if ( w == GetMainWidget() )
 {
 GetMainWidget().Update();
 m_Parent.OnChildRemove( w, child );
 }
 return true;
 }
 
 override bool OnChildAdd( Widget w, Widget child )
 {
 if ( w == GetMainWidget() )
 {
 GetMainWidget().Update();
 m_Parent.OnChildAdd( w, child );
 }
 return true;
 }
 
 override void CollapseButtonOnMouseButtonDown(Widget w)
 {
 super.CollapseButtonOnMouseButtonDown(w);
 ItemManager.GetInstance().SetDefaultHeaderOpenState( "VICINITY", !m_Hidden );
 }
 
 void UpdateHeader(EntityAI entity, Container cont, PlayerBase player)
 {
 bool draggable = ItemManager.GetInstance().EvaluateContainerDragabilityDefault(entity);
 
 if (cont.GetHeader())
 {
 if (GetDragWidget() == cont.GetHeader())
 {
 CancelWidgetDragging();
 }
 ItemManager.GetInstance().SetWidgetDraggable(cont.GetHeader().GetMainWidget(),draggable);
 }
 }
 
 override bool SplitItem()
 {
 if ( CanSplit() )
 {
 ItemBase item = ItemBase.Cast(GetFocusedItem());
 if (item)
 {
 if (item.HasQuantity() && item.CanBeSplit())
 {
 item.OnRightClick();
 }
 }
 }
 return false;
 }
}