e2 issue with VGUI core

[Doommarine1991]

made this works but there some issues

1. hitting E on the e2 chip works once then stops (no clue why)
2. sometimes the weapons list doesnt show all guns added

yet i have no clue why.......

@name Tabbed Entity Spawn Menu with Ammo System - Fixed
@inputs 
@outputs 
@persist Frame:dframe MenuOpen SpawnPos:vector CurrentTab:string
@persist [HealthBtn BatteryBtn CrateBtn]:dbutton
@persist [TabItems TabAmmo TabWeapons BackBtn]:dbutton
@persist [ItemsPanel AmmoPanel WeaponsPanel]:dpanel
@persist SpawnedHealthKits:array SpawnedBatteries:array SpawnedAmmoBoxes:array SpawnedWeapons:array
@persist AmmoPickupCounts:table WeaponPickupCounts:table
@persist WeaponButtonsCreated:number InitStage:number
@persist LastMenuToggle:number LastPickup:number JustClosedMenu:number
@trigger none

if (first()) {
    timer("init", 50)
    InitStage = 0
    WeaponButtonsCreated = 0
    LastMenuToggle = 0
    LastPickup = 0
    JustClosedMenu = 0
}

interval(20)

# -----------------------
# Helper function to get weapon info from button ID
function string getWeaponInfo(ID:number) {
    local Weapons = table()
    Weapons[41, string] = "Crowbar|weapon_crowbar|models/weapons/w_crowbar.mdl"
    Weapons[42, string] = "Stunstick|weapon_stunstick|models/weapons/w_stunbaton.mdl"
    Weapons[43, string] = "Pistol|weapon_pistol|models/weapons/w_pistol.mdl"
    Weapons[44, string] = "357 Magnum|weapon_357|models/weapons/w_357.mdl"
    Weapons[45, string] = "SMG|weapon_smg1|models/weapons/w_smg1.mdl"
    Weapons[46, string] = "AR2|weapon_ar2|models/weapons/w_irifle.mdl"
    Weapons[47, string] = "Shotgun|weapon_shotgun|models/weapons/w_shotgun.mdl"
    Weapons[48, string] = "Crossbow|weapon_crossbow|models/weapons/w_crossbow.mdl"
    Weapons[49, string] = "Grenade|weapon_frag|models/weapons/w_grenade.mdl"
    Weapons[50, string] = "RPG|weapon_rpg|models/weapons/w_rocket_launcher.mdl"
    Weapons[51, string] = "Gravity Gun|weapon_physcannon|models/weapons/w_physics.mdl"
    Weapons[52, string] = "Bugbait|weapon_bugbait|models/weapons/w_bugbait.mdl"
    
    return Weapons[ID, string]
}

# -----------------------
# Helper function to get ammo type info
# -----------------------
function string getAmmoModel(ID:number) {
    local Models = table()
    Models[31, string] = "Pistol|models/items/boxsrounds.mdl"
    Models[32, string] = "SMG1|models/items/boxmrounds.mdl"
    Models[33, string] = "AR2|models/items/combine_rifle_cartridge01.mdl"
    Models[34, string] = "357|models/items/357ammo.mdl"
    Models[35, string] = "Buckshot|models/items/boxbuckshot.mdl"
    Models[36, string] = "AlyxGun|models/items/combine_rifle_cartridge01.mdl"
    
    return Models[ID, string]
}

# -----------------------
# Initialization - Stage 1
# -----------------------
if (clk("init") && InitStage == 0) {
    runOnKeys(owner(), 1)

    MenuOpen = 0
    CurrentTab = "items"
    SpawnedHealthKits = array()
    SpawnedBatteries = array()
    SpawnedAmmoBoxes = array()
    SpawnedWeapons = array()
    AmmoPickupCounts = table()
    WeaponPickupCounts = table()

    # Holo indicator
    holoCreate(1)
    SpawnPos = entity():pos() + entity():up() * 50
    holoPos(1, SpawnPos)
    holoModel(1, "models/holograms/hq_sphere.mdl")
    holoScale(1, vec(0.3, 0.3, 0.3))
    holoColor(1, vec4(0, 255, 0, 150))
    holoParent(1, entity())

    # UI Frame
    Frame = dframe(1)
    Frame:setTitle("Spawn Menu")
    Frame:setSize(350, 550)
    Frame:center()
    Frame:showCloseButton(1)
    Frame:setBackgroundBlur(1)
    Frame:setVisible(0)
    Frame:create()

    # Tab buttons panel
    local TabPanel = dpanel(2, Frame)
    TabPanel:dock(_DOCK_TOP)
    TabPanel:setHeight(50)
    TabPanel:create()

    # Items Tab Button
    TabItems = dbutton(20, TabPanel)
    TabItems:dock(_DOCK_LEFT)
    TabItems:setWidth(100)
    TabItems:dockMargin(5, 5, 5, 5)
    TabItems:setText("Items")
    TabItems:create()

    # Ammo Tab Button
    TabAmmo = dbutton(21, TabPanel)
    TabAmmo:dock(_DOCK_LEFT)
    TabAmmo:setWidth(100)
    TabAmmo:dockMargin(0, 5, 5, 5)
    TabAmmo:setText("Ammo")
    TabAmmo:create()

    # Weapons Tab Button
    TabWeapons = dbutton(22, TabPanel)
    TabWeapons:dock(_DOCK_LEFT)
    TabWeapons:setWidth(100)
    TabWeapons:dockMargin(0, 5, 5, 5)
    TabWeapons:setText("Weapons")
    TabWeapons:create()

    InitStage = 1
    timer("init2", 50)
}

# -----------------------
# Initialization - Stage 2 (Items Panel)
# -----------------------
if (clk("init2") && InitStage == 1) {
    # Items Panel
    ItemsPanel = dpanel(3, Frame)
    ItemsPanel:dock(_DOCK_FILL)
    ItemsPanel:setVisible(1)
    ItemsPanel:create()

    # Health Kit Button
    HealthBtn = dbutton(10, ItemsPanel)
    HealthBtn:dock(_DOCK_TOP)
    HealthBtn:dockMargin(5, 5, 5, 0)
    HealthBtn:setHeight(25)
    HealthBtn:setText("Health Kit")
    HealthBtn:create()

    # Battery Button
    BatteryBtn = dbutton(12, ItemsPanel)
    BatteryBtn:dock(_DOCK_TOP)
    BatteryBtn:dockMargin(5, 5, 5, 0)
    BatteryBtn:setHeight(25)
    BatteryBtn:setText("Battery")
    BatteryBtn:create()

    # Wood Crate Button
    CrateBtn = dbutton(15, ItemsPanel)
    CrateBtn:dock(_DOCK_TOP)
    CrateBtn:dockMargin(5, 5, 5, 0)
    CrateBtn:setHeight(25)
    CrateBtn:setText("Wood Crate")
    CrateBtn:create()

    InitStage = 2
    timer("init3", 50)
}

# -----------------------
# Initialization - Stage 3 (Ammo Panel)
# -----------------------
if (clk("init3") && InitStage == 2) {
    # Ammo Panel
    AmmoPanel = dpanel(4, Frame)
    AmmoPanel:dock(_DOCK_FILL)
    AmmoPanel:setVisible(0)
    AmmoPanel:create()

    # Ammo type buttons (ID 30-39 for ammo)
    local AmmoTypes = table()
    AmmoTypes[1, string] = "Pistol|models/items/boxsrounds.mdl"
    AmmoTypes[2, string] = "SMG1|models/items/boxmrounds.mdl"
    AmmoTypes[3, string] = "AR2|models/items/combine_rifle_cartridge01.mdl"
    AmmoTypes[4, string] = "357|models/items/357ammo.mdl"
    AmmoTypes[5, string] = "Buckshot|models/items/boxbuckshot.mdl"
    AmmoTypes[6, string] = "AlyxGun|models/items/combine_rifle_cartridge01.mdl"

    for (I = 1, 6) {
        local Data = AmmoTypes[I, string]:explode("|")
        local AmmoName = Data[1, string]
        local AmmoModel = Data[2, string]
        
        local Btn = dbutton(30 + I, AmmoPanel)
        Btn:dock(_DOCK_TOP)
        Btn:dockMargin(5, 5, 5, 0)
        Btn:setHeight(25)
        Btn:setText(AmmoName + " Ammo")
        Btn:create()
    }

    InitStage = 3
    timer("init4", 50)
}

# -----------------------
# Initialization - Stage 4 (Weapons Panel)
# -----------------------
if (clk("init4") && InitStage == 3) {
    # Weapons Panel
    WeaponsPanel = dpanel(5, Frame)
    WeaponsPanel:dock(_DOCK_FILL)
    WeaponsPanel:setVisible(0)
    WeaponsPanel:create()

    InitStage = 4
    WeaponButtonsCreated = 0
    timer("createWeapons", 5)
}

# -----------------------
# Create Weapon Buttons Gradually
# -----------------------
if (clk("createWeapons") && InitStage == 4) {
    local WeaponTypes = table()
    WeaponTypes[1, string] = "Crowbar|weapon_crowbar|models/weapons/w_crowbar.mdl"
    WeaponTypes[2, string] = "Stunstick|weapon_stunstick|models/weapons/w_stunbaton.mdl"
    WeaponTypes[3, string] = "Pistol|weapon_pistol|models/weapons/w_pistol.mdl"
    WeaponTypes[4, string] = "357 Magnum|weapon_357|models/weapons/w_357.mdl"
    WeaponTypes[5, string] = "SMG|weapon_smg1|models/weapons/w_smg1.mdl"
    WeaponTypes[6, string] = "AR2|weapon_ar2|models/weapons/w_irifle.mdl"
    WeaponTypes[7, string] = "Shotgun|weapon_shotgun|models/weapons/w_shotgun.mdl"
    WeaponTypes[8, string] = "Crossbow|weapon_crossbow|models/weapons/w_crossbow.mdl"
    WeaponTypes[9, string] = "Grenade|weapon_frag|models/weapons/w_grenade.mdl"
    WeaponTypes[10, string] = "RPG|weapon_rpg|models/weapons/w_rocket_launcher.mdl"
    WeaponTypes[11, string] = "Gravity Gun|weapon_physcannon|models/weapons/w_physics.mdl"
    WeaponTypes[12, string] = "Bugbait|weapon_bugbait|models/weapons/w_bugbait.mdl"

    # Create 3 weapon buttons per tick to avoid hitting creation limits
    local StartIdx = WeaponButtonsCreated + 1
    local EndIdx = min(WeaponButtonsCreated + 3, 12)
    
    for (I = StartIdx, EndIdx) {
        local Data = WeaponTypes[I, string]:explode("|")
        local WeaponName = Data[1, string]
        
        local Btn = dbutton(40 + I, WeaponsPanel)
        Btn:dock(_DOCK_TOP)
        Btn:dockMargin(5, 2, 5, 0)
        Btn:setHeight(30)
        Btn:setText(WeaponName)
        Btn:create()
        
        WeaponButtonsCreated = WeaponButtonsCreated + 1
    }
    
    # If we haven't created all 12 weapons yet, schedule another tick
    if (WeaponButtonsCreated < 12) {
        timer("createWeapons", 5)
    } else {
        # All done, finalize
        WeaponsPanel:modify()
        Frame:modify()
        InitStage = 5
        print("Menu initialization complete!")
    }
}

# -----------------------
# vguiClk - Button Click Handler
# -----------------------
event vguiClk(Player:entity, ID:number, Values:table)
{
    if (Player == owner() && InitStage == 5) {
        # Tab switching
        if (ID == TabItems:id()) {
            ItemsPanel:setVisible(1)
            AmmoPanel:setVisible(0)
            WeaponsPanel:setVisible(0)
            ItemsPanel:modify()
            AmmoPanel:modify()
            WeaponsPanel:modify()
            CurrentTab = "items"
        }
        elseif (ID == TabAmmo:id()) {
            ItemsPanel:setVisible(0)
            AmmoPanel:setVisible(1)
            WeaponsPanel:setVisible(0)
            ItemsPanel:modify()
            AmmoPanel:modify()
            WeaponsPanel:modify()
            CurrentTab = "ammo"
        }
        elseif (ID == TabWeapons:id()) {
            ItemsPanel:setVisible(0)
            AmmoPanel:setVisible(0)
            WeaponsPanel:setVisible(1)
            ItemsPanel:modify()
            AmmoPanel:modify()
            WeaponsPanel:modify()
            CurrentTab = "weapons"
        }
        # Items tab buttons
        elseif (ID == HealthBtn:id()) {
            local Kit = sentSpawn("item_healthkit", SpawnPos, ang(), 0)
            if (Kit:isValid()) { SpawnedHealthKits:pushEntity(Kit) }
            Frame:setVisible(0)
            Frame:modify()
            MenuOpen = 0
            JustClosedMenu = 1
            timer("clearMenuFlag", 500)
        }
        elseif (ID == BatteryBtn:id()) {
            local Batt = sentSpawn("item_battery", SpawnPos, ang(), 0)
            if (Batt:isValid()) { SpawnedBatteries:pushEntity(Batt) }
            Frame:setVisible(0)
            Frame:modify()
            MenuOpen = 0
            JustClosedMenu = 1
            timer("clearMenuFlag", 500)
        }
        elseif (ID == CrateBtn:id()) {
            propSpawnEffect(0)
            local Ent = propSpawn("models/props_junk/wood_crate001a.mdl", SpawnPos, ang(), 0)
            if (Ent:isValid()) { Ent:propFreeze(0) }
            Frame:setVisible(0)
            Frame:modify()
            MenuOpen = 0
            JustClosedMenu = 1
            timer("clearMenuFlag", 500)
        }
        # Ammo spawning (ID 31-36)
        elseif (ID >= 31 && ID <= 36) {
            local AmmoInfo = getAmmoModel(ID):explode("|")
            local AmmoType = AmmoInfo[1, string]
            local AmmoModel = AmmoInfo[2, string]
            
            propSpawnEffect(0)
            local AmmoBox = propSpawn(AmmoModel, SpawnPos, ang(), 0)
            if (AmmoBox:isValid()) {
                AmmoBox:setName(AmmoType)
                SpawnedAmmoBoxes:pushEntity(AmmoBox)
            }
            Frame:setVisible(0)
            Frame:modify()
            MenuOpen = 0
            JustClosedMenu = 1
            timer("clearMenuFlag", 500)
        }
        # Weapon spawning (ID 41-52)
        elseif (ID >= 41 && ID <= 52) {
            local WeaponInfo = getWeaponInfo(ID):explode("|")
            if (WeaponInfo:count() >= 3) {
                local WeaponName = WeaponInfo[1, string]
                local WeaponClass = WeaponInfo[2, string]
                local WeaponModel = WeaponInfo[3, string]
                
                # Check if player already has this weapon
                if (WeaponPickupCounts:exists(WeaponClass) && WeaponPickupCounts[WeaponClass, number] >= 1) {
                    Player:emitSound("@buttons/button10.wav", 80, 100, 1.0)
                    printColor(Player, vec(255,100,100), "[DENIED] You already have this weapon!")
                } else {
                    propSpawnEffect(0)
                    local WeaponProp = propSpawn(WeaponModel, SpawnPos, ang(), 0)
                    if (WeaponProp:isValid()) {
                        WeaponProp:setName(WeaponClass)
                        SpawnedWeapons:pushEntity(WeaponProp)
                    }
                    Frame:setVisible(0)
                    Frame:modify()
                    MenuOpen = 0
                    JustClosedMenu = 1
                    timer("clearMenuFlag", 500)
                }
            }
        }
    }
}

# Clear the menu closed flag
if (clk("clearMenuFlag")) {
    JustClosedMenu = 0
}

# -----------------------
# Menu Toggle with E key when looking at chip
# -----------------------
if (keyClk(owner()) && owner():keyUse() && InitStage == 5) {
    local CurrentTime = curtime()
    local Trace = owner():eyeTrace()
    
    # Check if looking at the chip
    if (Trace:entity() == entity() && Trace:distance() < 150) {
        # Only toggle menu if enough time has passed since last toggle
        if (CurrentTime - LastMenuToggle >= 200) {
            if (MenuOpen) {
                Frame:setVisible(0)
                Frame:modify()
                MenuOpen = 0
                JustClosedMenu = 1
                timer("clearMenuFlag", 500)
            } else {
                Frame:setVisible(1)
                Frame:makePopup()
                Frame:modify()
                MenuOpen = 1
            }
            LastMenuToggle = CurrentTime
        }
    }
}

# -----------------------
# PICKUP SYSTEM (E key) - Only when NOT looking at chip
# -----------------------
if (keyClk(owner()) && owner():keyUse() && InitStage == 5 && !MenuOpen && !JustClosedMenu) {
    local Player = owner()
    local CurrentTime = curtime()
    local Trace = owner():eyeTrace()
    local LookedAtEntity = Trace:entity()
    local Distance = Trace:distance()

    # Don't pickup if looking at the chip or if recently picked something up
    if (LookedAtEntity != entity() && LookedAtEntity:isValid() && Distance < 150 && (CurrentTime - LastPickup >= 200)) {

        # --- HEALTH KIT PICKUP ---
        for (I = SpawnedHealthKits:count(), 1, -1) {
            local Kit = SpawnedHealthKits[I, entity]
            if (Kit:isValid() && LookedAtEntity == Kit) {
                local Denied = 0
                local MaxHealth = 500
                local Cap = 800
                local Add = 100
                local Cur = Player:health()

                if (Cur < MaxHealth) {
                    Player:setHealth(MaxHealth)
                    Player:emitSound("@items/smallmedkit1.wav", 80, 100, 1.0)
                    printColor(Player, vec(100,255,100), "Health restored to " + MaxHealth)
                } elseif (Cur >= Cap) {
                    Denied = 1
                    Player:emitSound("@buttons/button10.wav", 80, 100, 1.0)
                    printColor(Player, vec(255,100,100), "[HEALTH MAXED] You are at maximum health cap (" + Cap + ")!")
                } else {
                    local New = Cur + Add
                    if (New > Cap) {
                        Player:setHealth(Cap)
                        Player:emitSound("@items/smallmedkit1.wav", 80, 100, 1.0)
                        printColor(Player, vec(255,255,100), "Health maxed at cap (" + Cap + ")!")
                    } else {
                        Player:setHealth(New)
                        Player:emitSound("@items/smallmedkit1.wav", 80, 100, 1.0)
                        printColor(Player, vec(100,255,100), "Health: " + New + "/" + Cap)
                    }
                }

                Kit:propDelete()
                SpawnedHealthKits:removeEntity(I)
                LastPickup = CurrentTime
                break
            }
        }

        # --- BATTERY PICKUP ---
        for (I = SpawnedBatteries:count(), 1, -1) {
            local Batt = SpawnedBatteries[I, entity]
            if (Batt:isValid() && LookedAtEntity == Batt) {
                local Denied = 0
                local Max = 500
                local Cap = 800
                local Add = 100
                local Cur = Player:armor()

                if (Cur < Max) {
                    Player:plySetArmor(Max)
                    Player:emitSound("@items/battery_pickup.wav", 80, 100, 1.0)
                    printColor(Player, vec(100,255,100), "Armor restored to " + Max)
                } elseif (Cur >= Cap) {
                    Denied = 1
                    Player:emitSound("@buttons/button10.wav", 80, 100, 1.0)
                    printColor(Player, vec(255,100,100), "[ARMOR MAXED] You are at maximum armor cap (" + Cap + ")!")
                } else {
                    local New = Cur + Add
                    if (New > Cap) {
                        Player:plySetArmor(Cap)
                        Player:emitSound("@items/battery_pickup.wav", 80, 100, 1.0)
                        printColor(Player, vec(255,255,100), "Armor maxed at cap (" + Cap + ")!")
                    } else {
                        Player:plySetArmor(New)
                        Player:emitSound("@items/battery_pickup.wav", 80, 100, 1.0)
                        printColor(Player, vec(100,255,100), "Armor: " + New + "/" + Cap)
                    }
                }

                Batt:propDelete()
                SpawnedBatteries:removeEntity(I)
                LastPickup = CurrentTime
                break
            }
        }

        # --- AMMO BOX PICKUP ---
        for (I = SpawnedAmmoBoxes:count(), 1, -1) {
            local Box = SpawnedAmmoBoxes[I, entity]
            if (Box:isValid() && LookedAtEntity == Box) {
                local AmmoType = Box:getName()
                
                if (!AmmoPickupCounts:exists(AmmoType)) {
                    AmmoPickupCounts[AmmoType, number] = 0
                }
                
                local TotalAmmoGiven = AmmoPickupCounts[AmmoType, number]
                local AmmoCap = 2000
                
                if (TotalAmmoGiven >= AmmoCap) {
                    Player:emitSound("@buttons/button10.wav", 80, 100, 1.0)
                    printColor(Player, vec(255,100,100), "[AMMO MAXED] You are at maximum " + AmmoType + " ammo cap (" + AmmoCap + ")!")
                } else {
                    local AmmoToGive = 500
                    if (TotalAmmoGiven > 0) {
                        AmmoToGive = 200
                    }
                    
                    AmmoToGive = min(AmmoToGive, AmmoCap - TotalAmmoGiven)
                    
                    Player:giveAmmo(AmmoToGive, AmmoType)
                    AmmoPickupCounts[AmmoType, number] = TotalAmmoGiven + AmmoToGive
                    
                    local NewTotal = AmmoPickupCounts[AmmoType, number]
                    Player:emitSound("@items/ammo_pickup.wav", 80, 100, 1.0)
                    
                    if (NewTotal >= AmmoCap) {
                        printColor(Player, vec(255,255,100), "Picked up " + AmmoToGive + " " + AmmoType + " ammo. [MAXED at " + AmmoCap + "]")
                    } else {
                        printColor(Player, vec(100,255,100), "Picked up " + AmmoToGive + " " + AmmoType + " ammo. (Total: " + NewTotal + "/" + AmmoCap + ")")
                    }
                }
                
                Box:propDelete()
                SpawnedAmmoBoxes:removeEntity(I)
                LastPickup = CurrentTime
                break
            }
        }

        # --- WEAPON PICKUP ---
        for (I = SpawnedWeapons:count(), 1, -1) {
            local Weapon = SpawnedWeapons[I, entity]
            if (Weapon:isValid() && LookedAtEntity == Weapon) {
                local WeaponClass = Weapon:getName()
                
                # Check if we've already picked up this weapon type
                if (!WeaponPickupCounts:exists(WeaponClass)) {
                    WeaponPickupCounts[WeaponClass, number] = 0
                }
                
                local WeaponCap = 1  # Can only have 1 of each weapon
                local AlreadyHas = WeaponPickupCounts[WeaponClass, number]
                
                # Always delete the weapon prop first
                Weapon:propDelete()
                SpawnedWeapons:removeEntity(I)
                
                if (AlreadyHas >= WeaponCap) {
                    Player:emitSound("@buttons/button10.wav", 80, 100, 1.0)
                    printColor(Player, vec(255,100,100), "[DENIED] You already have this weapon!")
                } else {
                    Player:giveWeapon(WeaponClass)
                    WeaponPickupCounts[WeaponClass, number] = 1
                    Player:emitSound("@items/ammo_pickup.wav", 80, 100, 1.0)
                    printColor(Player, vec(100,255,100), "Picked up " + WeaponClass + "!")
                }
                
                LastPickup = CurrentTime
                break
            }
        }
    }
}

# -----------------------
# CLEANUP INVALID ENTRIES
# -----------------------
for (A = SpawnedAmmoBoxes:count(), 1, -1) {
    if (!SpawnedAmmoBoxes[A, entity]:isValid()) { SpawnedAmmoBoxes:removeEntity(A) }
}
for (H = SpawnedHealthKits:count(), 1, -1) {
    if (!SpawnedHealthKits[H, entity]:isValid()) { SpawnedHealthKits:removeEntity(H) }
}
for (B = SpawnedBatteries:count(), 1, -1) {
    if (!SpawnedBatteries[B, entity]:isValid()) { SpawnedBatteries:removeEntity(B) }
}
for (W = SpawnedWeapons:count(), 1, -1) {
    if (!SpawnedWeapons[W, entity]:isValid()) { SpawnedWeapons:removeEntity(W) }
}
```

[Linus045]

1.1)

You need to set Frame:setDeleteOnClose(0) otherwise closing the frame will delete it on the clients instead of just hiding it.

    # UI Frame
    Frame = dframe(1)
    Frame:setTitle("Spawn Menu")
    Frame:setSize(350, 550)
    Frame:center()
    Frame:showCloseButton(1)
    Frame:setBackgroundBlur(1)
    Frame:setDeleteOnClose(0)  <------ add this somewhere before calling create()
    Frame:setVisible(0)
    Frame:create()

1.2)

In line 392 if (CurrentTime - LastMenuToggle >= 200) { CurrentTime and LastMenuToggle is in seconds and not milliseconds, so a value of 0.2 would be more appropriate, though in general I'm not sure why you need the time comparision at all, you can just rely on the value from keyClk(owner()) and keyClkPressedBind() since you use runOnKeys() anyway i.e.

runOnKeys(owner(),1)

if(keyClkPressedBind() == "use") {
  if(keyClk(owner()) == 1) {
   print("keyUse was pressed down")
  }elseif(keyClk(owner()) == -1) {
   print("keyUse was released")
  }
}

The keyUse() function is more or less meant to be checked continuously in a loop to keep some action going, and not really meant as a trigger button (at least to my understanding).

Also I would highly recommend to switch to the keyClk event instead, seeing that you're already using the vgui event.

1.3)

Sadly there is currently no way to get an event when the close button is being clicked, meaning runOnVgui does not trigger in that case.
You you could check D:isVisible(owner()) though, which gets updated when you close the frame with the default close button.
Keep in mind to disable "delete on close" (Frame:setDeleteOnClose(0)).

As an example:

@persist D:dframe
@strict

# TODO: use lambda timers instead of interval() for better performance
interval(1000)

if(first()) {
    entity():setName("Press E to open the menu again")
    D = dframe(1)
    D:center()
    D:makePopup()
    # disable deletion when pressing the close button
    D:setDeleteOnClose(0)
    D:create()
    
    runOnKeys(owner(), 1)
}elseif(keyClk(owner()) == 1) { # check if the user pressed a button down
    if(keyClkPressedBind() == "use") {
        print("Opening Menu")
        D:setVisible(1)
        D:makePopup()
        D:modify()
    }
    # since we will be closing the menu via the close button, there is no need to manually close it by calling setVisible(0)
}elseif(clk()) {
    # continuouly print the current visibility state for demonstration purposes
    print(D:isVisible(owner()) ? "Frame is visible" : "Frame is hidden")    
}

The best way however would probably be to manually add a custom close button and hide the default one with Frame:showCloseButton(0). That way you can use the vgui-event to see when someone pressed the close button and do some additional logic.

I hope this clears up any problems, though feel free to ask additional questions if you have any, otherwise you can close the issue.

[Linus045]

2)

Oh and regarding your second point, why the gun list missing some items.
There is a limit on how many :create() and :modify() calls you can perform per second, check the ConVar wire_vgui_maxPanelsPerSecond (20 per second is the default).

You're creating elements too fast inside the for-loop on line 248.
If you surround the create() call with this snippet it highlights the problem:

if(vguiCanSend()) {
    Btn:create()
}else{
    error("vguiCanSend() returned false, we are calling create()/modify() too often in a single second")
}     

You can check if you are able to call :create() and :modify() using vguiCanSend(), it returns 0 or 1 depending on whether the limit has been reached or not (similar to propCanCreate() or holoCanCreate().

---

General note on why there is even a limit:

I have some problems with implementing a good system to create a bunch of vgui elements at once since every create/modify call is send from the server to the clients. Allowing 1000s of create/modify calls and therefore as many network messages in a single second did not feel like a good idea that's why there is a limit.

If you have permission to change server-side ConVars, you could play with the wire_vgui_maxPanelsPerSecond value and find a happy medium, the default of 20 per second might just be too low.

As a practical workaround I've come up with a queue example that enqueues objects to be created later. Even though it's not a perfect/pretty solution it's probably the best way to create a bunch of elements as fast as possible.
(also please keep in mind that I haven't kept up with the "recent" e2 changes like events, lamdas etc. so there are some improvements to be made)

@name Vgui Create Queue
@persist VguiCreateQueue:table J D:dframe

if(first()) {
    # Create a queue that will hold the objects to be created
    VguiCreateQueue=table()
    J = 0

    D = dframe(-1)
    D:center()
    D:setSize(1000,800)
    D:setColor(20,20,20)
    
    # set visible to 0 to show creation of elements
    D:setVisible(1)
    D:create()

    # add 30 dbuttons to the queue
    local Idx = 1
    for(I=1, 30) {
        local Btn = dbutton(Idx, D)
        Btn:dock(_DOCK_TOP)
        Btn:setText(""+ I)

        VguiCreateQueue:pushArray(array(Btn, "dbutton"))
        Idx++
    }
    
    local TextLabel = dlabel(100,D)
    TextLabel:setText("Some text")
    TextLabel:dock(_DOCK_TOP)
    TextLabel:setSize(200,40)
    TextLabel:setFont("", 40)
    VguiCreateQueue:pushArray(array(TextLabel, "dlabel"))


    # add 12 dpanels to the queue
    for(_=1, 12) {
        local Pnl = dpanel(Idx, D)
        Pnl:dock(_DOCK_RIGHT)
        Pnl:setColor(randvec(vec(120,120,120),vec(255,255,255)))

        VguiCreateQueue:pushArray(array(Pnl, "dpanel"))
        Idx++
    }        

    # start loop
    interval(1)
}elseif(clk()) {
    if(J <= VguiCreateQueue:count()) {
        # the limit resets each second (1000 milliseconds) and we can create 20 
        # elements (by default see ConVar: wire_vgui_maxPanelsPerSecond)
        # so 1000/20 gives us something close to the perfect delay between each create call
        interval(1000/20)

        # only create elements if the limit is not yet reaached
        if(vguiCanSend()) {
            local Obj = VguiCreateQueue[J, array]
            # get the type of the element so we can call create
            switch(Obj[2,string]) {
                case "dbutton",
                    Obj[1,dbutton]:create()
                break
                case "dpanel",
                    Obj[1,dpanel]:create()
                break
                case "dlabel",
                    Obj[1,dlabel]:create()
                break
            }
            J++
        }else{
            print("limit reached, we need to wait a bit")
        }
    }else{
        # once all elements are created, show the frame
        D:setVisible(1)
        D:modify()
    }
}