diff --git a/Content.Client/_Cats/Event/EventItemDispenserConfigBoundUserInterface.cs b/Content.Client/_Cats/Event/EventItemDispenserConfigBoundUserInterface.cs
new file mode 100644
index 00000000000..5c0c6fd93d0
--- /dev/null
+++ b/Content.Client/_Cats/Event/EventItemDispenserConfigBoundUserInterface.cs
@@ -0,0 +1,281 @@
+using Content.Client.UserInterface.Controls;
+using Content.Shared._Cats.Event;
+using Robust.Client.UserInterface;
+using Robust.Client.UserInterface.Controls;
+using Robust.Client.UserInterface.CustomControls;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Utility;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Content.Client._Cats.Event;
+
+#pragma warning disable IDE1006 // i am going to fucking lose it
+
+/// <summary>
+/// Hopefully i never have to touch UI ever again.
+/// Even if xaml thing was working for me, this would only be marginally less of a radioactive dump.
+/// </summary>
+public sealed class EventItemDispenserConfigBoundUserInterface : BoundUserInterface
+{
+
+    [Dependency] private readonly IPrototypeManager _proto = default!;
+    [Dependency] private readonly IEntityManager _entMan = default!;
+    [Dependency] private readonly ILocalizationManager _loc = default!;
+
+    static readonly Color Green = new Color(0, 255, 0);
+    static readonly Color Red = new Color(255, 0, 0);
+    static readonly Color Transparent = new Color(255, 255, 255, 69/*haha*/);
+
+    //EventItemDispenserConfigWindow? window; // Trying to work with robustengine's ui system makes me want to quote AM.
+    DefaultWindow window = default!;
+    EventItemDispenserComponent dispenserComp;
+    public EventItemDispenserConfigBoundUserInterface(EntityUid owner, Enum uiKey) : base(owner, uiKey) {
+        IoCManager.InjectDependencies(this);
+        dispenserComp = _entMan.GetComponent<EventItemDispenserComponent>(Owner);
+    }
+
+
+
+    #region man-made horrors beyond your comprehension 
+
+
+
+
+    #region all the controls
+    BoxContainer baseBox = default!;
+    BoxContainer optionBox = default!;
+    BoxContainer buttonBox = default!;
+    BoxContainer copypasteBox = default!;
+
+    LineEdit DispensingPrototypeLineEdit = default!;
+    bool DispensingPrototypeValid = false;
+    CheckBox AutoDisposeCheckBox = default!;
+    Label AutoDisposeLabel = default!;
+    CheckBox CanManuallyDisposeCheckBox = default!;
+    CheckBox InfiniteCheckBox = default!;
+    LineEdit LimitLineEdit = default!;
+
+    CheckBox ReplaceDisposedItemsCheckBox = default!;
+    LineEdit DisposedReplacementPrototypeLineEdit = default!;
+    bool DisposedReplacementPrototypeValid = false;
+
+    CheckBox AutoCleanUpCheckBox = default!;
+
+    Button copyButton = default!;
+    Button pasteButton = default!;
+    Button confirmButton = default!;
+
+    //Button cancelButton = new(); // just hit the "x" 4head
+    #endregion
+
+    #region copypasta stuff
+    static string SavedDispensingPrototype = default!;
+    static bool SavedAutoDispose = default;
+    static bool SavedCanManuallyDispose = default;
+    static bool SavedInfinite = default;
+    static string SavedLimit = default!;
+    static bool SavedReplaceDisposedItems = default;
+    static string SavedDisposedReplacementPrototype = default!;
+    static bool SavedAutoCleanUp = default;
+
+    static bool saved = false;
+
+    private void CopySettings(EventArgs whatever)
+    {
+        saved = true;
+
+        SavedDispensingPrototype = DispensingPrototypeLineEdit.Text;
+        SavedAutoDispose = AutoDisposeCheckBox.Pressed;
+        SavedCanManuallyDispose = CanManuallyDisposeCheckBox.Pressed;
+        SavedInfinite = InfiniteCheckBox.Pressed;
+        SavedLimit = LimitLineEdit.Text;
+        SavedReplaceDisposedItems = ReplaceDisposedItemsCheckBox.Pressed;
+        SavedDisposedReplacementPrototype = DisposedReplacementPrototypeLineEdit.Text;
+        SavedAutoCleanUp = AutoCleanUpCheckBox.Pressed;
+
+        pasteButton.Disabled = false;
+    }
+
+    private void PasteSettings(EventArgs whatever)
+    {
+        DebugTools.Assert(saved);
+
+        DispensingPrototypeLineEdit.Text = SavedDispensingPrototype;
+        AutoDisposeCheckBox.Pressed = SavedAutoDispose;
+        CanManuallyDisposeCheckBox.Pressed = SavedCanManuallyDispose;
+        InfiniteCheckBox.Pressed = SavedInfinite;
+        LimitLineEdit.Text = SavedLimit;
+        ReplaceDisposedItemsCheckBox.Pressed = SavedReplaceDisposedItems;
+        DisposedReplacementPrototypeLineEdit.Text = SavedDisposedReplacementPrototype;
+        AutoCleanUpCheckBox.Pressed = SavedAutoCleanUp;
+        
+    }
+    #endregion
+
+    private void InitializeControls(DefaultWindow window) // windows forms ahh method 
+    {
+        baseBox = this.CreateDisposableControl<BoxContainer>();
+        baseBox.Orientation = BoxContainer.LayoutOrientation.Vertical;
+        baseBox.SeparationOverride = 4;
+        baseBox.Margin = new Thickness(4, 0);
+        baseBox.MinWidth = 450;
+        window.Contents.AddChild(baseBox);
+
+        optionBox = this.CreateDisposableControl<BoxContainer>();
+        optionBox.Orientation = BoxContainer.LayoutOrientation.Vertical;
+        baseBox.AddChild(optionBox);
+
+        buttonBox = this.CreateDisposableControl<BoxContainer>();
+        buttonBox.Orientation = BoxContainer.LayoutOrientation.Horizontal;
+        //buttonBox.Align = BoxContainer.AlignMode.End;
+        baseBox.AddChild(buttonBox);
+
+        copypasteBox = this.CreateDisposableControl<BoxContainer>();
+        //copypasteBox.HorizontalAlignment = Control.HAlignment.Left;
+        copypasteBox.HorizontalExpand = true;
+
+        copyButton = this.CreateDisposableControl<Button>();
+        copyButton.Label.Text = "Copy";
+        copyButton.OnPressed += CopySettings;
+        copypasteBox.AddChild(copyButton);
+
+        pasteButton = this.CreateDisposableControl<Button>();
+        pasteButton.Label.Text = "Paste";
+        pasteButton.OnPressed += PasteSettings;
+        pasteButton.Disabled = !saved;
+        copypasteBox.AddChild(pasteButton);
+
+        confirmButton = this.CreateDisposableControl<Button>();
+        confirmButton.Label.Text = "OK";
+        confirmButton.OnPressed += TrySubmit;
+        confirmButton.HorizontalAlignment = Control.HAlignment.Right;
+
+        buttonBox.AddChild(copypasteBox);
+        buttonBox.AddChild(confirmButton);
+
+    }
+
+    private void ColorAutoDispose(EventArgs whatever = default!) // please put me out of my misery
+    {
+        AutoDisposeCheckBox.Disabled = !InfiniteCheckBox.Pressed;
+        //AutoDisposeCheckBox.ModulateSelfOverride = AutoDisposeCheckBox.Disabled ? Transparent : null; // doesn't work :(
+        AutoDisposeLabel.ModulateSelfOverride = AutoDisposeCheckBox.Disabled ? Transparent : null;
+
+    }
+
+    /// <summary>
+    /// I am not sorry.
+    /// </summary>
+    protected override void Open() // pure aids
+    {
+        base.Open(); // what's the fucking point?
+        window = this.CreateDisposableControl<DefaultWindow>();
+        window.Resizable = false;
+        window.OnClose += Close;
+        InitializeControls(window);
+
+        window.Title = _loc.GetString("eventitemdispenser-configwindow-title");
+        DispensingPrototypeLineEdit = AddOption<LineEdit>("eventitemdispenser-configwindow-dispensingprototype");
+        DispensingPrototypeLineEdit.MinWidth = 300;
+        DispensingPrototypeLineEdit.OnTextChanged += (args) => { DispensingPrototypeValid = ValidateProto(args); confirmButton!.Disabled = !DispensingPrototypeValid || !DisposedReplacementPrototypeValid; };
+        DispensingPrototypeLineEdit.OnTextEntered += TrySubmit;
+
+        (AutoDisposeCheckBox, AutoDisposeLabel) = _AddOption<CheckBox>("eventitemdispenser-configwindow-autodispose");
+        CanManuallyDisposeCheckBox = AddOption<CheckBox>("eventitemdispenser-configwindow-canmanuallydispose");
+
+        InfiniteCheckBox = AddOption<CheckBox>("eventitemdispenser-configwindow-infinite");
+        InfiniteCheckBox.OnPressed += ColorAutoDispose;
+
+
+        LimitLineEdit = AddOption<LineEdit>("eventitemdispenser-configwindow-limit");
+        LimitLineEdit.IsValid = s => int.TryParse(s, out int _) && s.IndexOf('-') == -1; // no "_ > 0" because being able to input -0 makes me cringe
+        LimitLineEdit.MinWidth = 100;
+        LimitLineEdit.OnTextEntered += TrySubmit;
+
+        ReplaceDisposedItemsCheckBox = AddOption<CheckBox>("eventitemdispenser-configwindow-replacedisposeditems");
+
+        DisposedReplacementPrototypeLineEdit = AddOption<LineEdit>("eventitemdispenser-configwindow-disposedreplacement");
+        DisposedReplacementPrototypeLineEdit.MinWidth = 300;
+        DisposedReplacementPrototypeLineEdit.OnTextChanged += (args) => { DisposedReplacementPrototypeValid = ValidateProto(args); confirmButton!.Disabled = !DispensingPrototypeValid || !DisposedReplacementPrototypeValid; };
+        DisposedReplacementPrototypeLineEdit.OnTextEntered += TrySubmit;
+
+        AutoCleanUpCheckBox = AddOption<CheckBox>("eventitemdispenser-configwindow-autocleanup");
+        
+        DispensingPrototypeLineEdit.SetText(dispenserComp.DispensingPrototype, true);
+        AutoDisposeCheckBox.Pressed = dispenserComp.AutoDispose;
+        CanManuallyDisposeCheckBox.Pressed = dispenserComp.CanManuallyDispose;
+        InfiniteCheckBox.Pressed = dispenserComp.Infinite;
+        ColorAutoDispose();
+        LimitLineEdit.SetText(dispenserComp.Limit.ToString());
+        ReplaceDisposedItemsCheckBox.Pressed = dispenserComp.ReplaceDisposedItems;
+        DisposedReplacementPrototypeLineEdit.SetText(dispenserComp.DisposedReplacement, true);
+        AutoCleanUpCheckBox.Pressed = dispenserComp.AutoCleanUp;
+
+        AutoDisposeCheckBox.Disabled = !dispenserComp.Infinite;
+
+        window.OpenCentered();
+    }
+    private T AddOption<T>(string text) where T : Control, IDisposable, new()
+    {
+        return _AddOption<T>(text).Item1;
+    }
+
+        private (T, Label) _AddOption<T>(string text) where T : Control, IDisposable, new()
+    {
+        var box = this.CreateDisposableControl<BoxContainer>();
+        box.HorizontalAlignment = Control.HAlignment.Stretch;
+        var label = this.CreateDisposableControl<Label>();
+        label.Text = _loc.GetString(text);
+        label.HorizontalExpand = true;
+        label.HorizontalAlignment = Label.HAlignment.Left;
+        box.AddChild(label);
+        var control = this.CreateDisposableControl<T>();
+        control.HorizontalAlignment = Control.HAlignment.Right;
+        control.ToolTip = _loc.GetString($"{text}-tooltip");
+        box.AddChild(control);
+        optionBox!.AddChild(box); // called after control init // i can't even remember what i meant by this, that's how bad it has got.
+        return (control, label);
+    }
+    private bool ValidateProto(LineEdit.LineEditEventArgs args)
+    {
+        bool val = _proto.HasIndex(args.Text);
+        args.Control.ModulateSelfOverride = val ? Green : Red;
+        return val;
+    }
+
+    private void TrySubmit(EventArgs whatever)
+    {
+        if (!confirmButton.Disabled)
+        {
+            var msg = new EventItemDispenserNewConfigBoundUserInterfaceMessage()
+            {
+                DispensingPrototype = DispensingPrototypeLineEdit.Text,
+                AutoDispose = AutoDisposeCheckBox.Pressed,
+                CanManuallyDispose = CanManuallyDisposeCheckBox.Pressed,
+                Infinite = InfiniteCheckBox.Pressed,
+                Limit = int.Parse(LimitLineEdit.Text),
+                ReplaceDisposedItems = ReplaceDisposedItemsCheckBox.Pressed,
+                DisposedReplacement = DisposedReplacementPrototypeLineEdit.Text,
+                AutoCleanUp = AutoCleanUpCheckBox.Pressed
+            };
+            SendMessage(msg);
+            Close();
+        }
+    }
+
+    protected override void ReceiveMessage(BoundUserInterfaceMessage message)
+    {
+        base.ReceiveMessage(message);
+        if(message is EventItemDispenserNewProtoBoundUserInterfaceMessage { } msg)
+        {
+            DispensingPrototypeLineEdit.SetText(msg.DispensingPrototype);
+        }
+    }
+    #endregion
+}
+#pragma warning restore IDE1006
\ No newline at end of file
diff --git a/Content.Client/_Cats/Event/EventItemDispenserSystem.cs b/Content.Client/_Cats/Event/EventItemDispenserSystem.cs
new file mode 100644
index 00000000000..9ba5f5a0a23
--- /dev/null
+++ b/Content.Client/_Cats/Event/EventItemDispenserSystem.cs
@@ -0,0 +1,54 @@
+using Content.Shared._Cats.Event;
+using Robust.Client.GameObjects;
+using Robust.Shared.Prototypes;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Content.Client._Cats.Event;
+
+public class EventItemDispenserSystem : SharedEventItemDispenserSystem
+{
+    [Dependency] private readonly IPrototypeManager _proto = default!;
+    [Dependency] private readonly SpriteSystem _sprite = default!;
+
+    public override void Initialize()
+    {
+        SubscribeLocalEvent<EventItemDispenserComponent, ComponentInit>(OnInit);
+        SubscribeLocalEvent<EventItemDispenserComponent, AfterAutoHandleStateEvent>(OnAfterAutoHandleState);
+    }
+
+    private void OnInit(EntityUid uid, EventItemDispenserComponent comp, ComponentInit args)
+    {
+        UpdateVisuals(uid, comp);
+    }
+
+    private void OnAfterAutoHandleState(EntityUid uid, EventItemDispenserComponent comp, AfterAutoHandleStateEvent args)
+    {
+        UpdateVisuals(uid, comp);
+    }
+
+    private void UpdateVisuals(EntityUid uid, EventItemDispenserComponent comp)
+    {
+        var sprite = Comp<SpriteComponent>(uid);
+        var icon = _sprite.GetPrototypeIcon(comp.DispensingPrototype).Default;
+        sprite.LayerSetTexture(EventItemDispenserVisualLayers.ItemPreview, icon);
+        float scale = comp.ItemPreviewScale;
+
+        if (scale <= 0)
+            scale = 32f / Math.Max(15, Math.Max(icon.Width, icon.Height));
+
+        sprite.LayerSetScale(EventItemDispenserVisualLayers.ItemPreview, new Vector2(scale));
+    }
+}
+
+enum EventItemDispenserVisualLayers : byte
+{
+    Base,
+    Lights,
+    Arms,
+    ItemPreview
+}
\ No newline at end of file
diff --git a/Content.Server/_Cats/Event/EventEntityDispenser/EventItemDispenserSystem.cs b/Content.Server/_Cats/Event/EventEntityDispenser/EventItemDispenserSystem.cs
new file mode 100644
index 00000000000..f7ec2b887d9
--- /dev/null
+++ b/Content.Server/_Cats/Event/EventEntityDispenser/EventItemDispenserSystem.cs
@@ -0,0 +1,373 @@
+using Content.Shared.Hands.EntitySystems;
+using Content.Shared.Interaction;
+using Robust.Shared.Utility;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Content.Shared._Cats.Event;
+using Robust.Shared.Audio.Systems;
+using Content.Server.Store.Systems;
+using Content.Server.Administration.Managers;
+using Content.Server.GameTicking;
+using Content.Shared.Popups;
+using Robust.Shared.Containers;
+using Content.Shared.Administration;
+using Robust.Shared.Prototypes;
+using Content.Shared.Examine;
+using Robust.Shared.Map;
+using Content.Shared.Ghost;
+using Content.Shared.Weapons.Ranged.Events;
+
+namespace Content.Server._Cats.Event;
+public class EventItemDispenserSystem : SharedEventItemDispenserSystem
+{
+    [Dependency] private readonly SharedHandsSystem _hands = default!;
+    [Dependency] private readonly SharedAudioSystem _audio = default!;
+    [Dependency] private readonly SharedPopupSystem _popup = default!;
+    [Dependency] private readonly SharedTransformSystem _transform = default!;
+    [Dependency] private readonly SharedContainerSystem _container = default!;
+    [Dependency] private readonly SharedUserInterfaceSystem _ui = default!;
+
+    [Dependency] private readonly IAdminManager _admeme = default!;
+    [Dependency] private readonly ILocalizationManager _loc = default!;
+    [Dependency] private readonly IPrototypeManager _proto = default!;
+
+    public override void Initialize()
+    {
+        SubscribeLocalEvent<EventItemDispenserComponent, ComponentRemove>(OnRemove);
+        SubscribeLocalEvent<EventItemDispenserComponent, InteractUsingEvent>(OnInteractUsing);
+        SubscribeLocalEvent<EventItemDispenserComponent, ActivateInWorldEvent>(OnActivateInWorld);
+
+        SubscribeLocalEvent<EventItemDispenserComponent, ExaminedEvent>(OnExamine);
+
+        SubscribeLocalEvent<EventItemDispenserComponent, EventItemDispenserNewConfigBoundUserInterfaceMessage>(OnMessage);
+
+        SubscribeLocalEvent<EventDispensedComponent, ComponentStartup>(OnDispensedStartup);
+        SubscribeLocalEvent<EventDispensedComponent, ComponentRemove>(OnDispensedRemove);
+    }
+
+
+
+    private void OnMessage(EntityUid uid, EventItemDispenserComponent comp, EventItemDispenserNewConfigBoundUserInterfaceMessage msg)
+    {
+        var adminData = _admeme.GetAdminData(msg.Actor);
+        if (adminData == null || !adminData.CanAdminPlace())
+        {
+            return;
+        }
+        string newProto = ValidateProto(msg.DispensingPrototype, comp.DispensingPrototype);
+        if (comp.DispensingPrototype != newProto) {
+            comp.DispensingPrototype = newProto;
+            DeleteAll(uid, comp);
+        }
+        comp.AutoDispose = msg.AutoDispose;
+        comp.CanManuallyDispose = msg.CanManuallyDispose;
+        comp.Infinite = msg.Infinite;
+        comp.Limit = msg.Limit;
+        comp.DisposedReplacement = ValidateProto(msg.DisposedReplacement, comp.DisposedReplacement);
+        comp.ReplaceDisposedItems = msg.ReplaceDisposedItems;
+        comp.AutoCleanUp = msg.AutoCleanUp;
+        Dirty(uid, comp);
+    }
+
+    private void OnDispensedStartup(EntityUid uid, EventDispensedComponent comp, ComponentStartup args)
+    {
+        if (!TryComp<ContainerManagerComponent>(uid, out var contManager))
+            return;
+
+        RecursiveSlaveAllContents(uid, comp);
+    }
+
+    private void RecursiveSlaveAllContents(EntityUid item, EventDispensedComponent comp, int depth = 0)
+    {
+        if (depth >= 5) // what the fuck kind of item is that?
+            throw new ArgumentException($"Item Uid:{item}, proto:\"{MetaData(item).EntityPrototype?.ID}\" has FIVE levels of storage component entities stored in each other. What the fuck?");
+        if (!HasComp<ContainerManagerComponent>(item))
+            return;
+        depth++;
+        RaiseLocalEvent(item, new ForceSpawnAmmoEvent());
+        var containers = _container.GetAllContainers(item);
+        bool more = false;
+        List<EntityUid> ents = new();
+        foreach (var container in containers)
+        {
+            ents.AddRange(container.ContainedEntities);
+        }
+        comp.Slaved.AddRange(ents);
+        foreach (var ent in ents)
+        {
+            RecursiveSlaveAllContents(ent, comp, depth);
+        }
+    }
+
+    private void OnDispensedRemove(EntityUid uid, EventDispensedComponent comp, ComponentRemove args)
+    {
+
+        foreach(var item in comp.Slaved)
+        {
+            QueueDel(item);
+        }
+    }
+
+    private void OnRemove(EntityUid uid, EventItemDispenserComponent comp, ComponentRemove args)
+    {
+        if (comp.AutoCleanUp)
+        {
+            DeleteAll(uid, comp);
+        }
+        else
+        {
+            ReleaseAll(uid, comp);
+        }
+    }
+
+    private void OnExamine(EntityUid uid, EventItemDispenserComponent comp, ExaminedEvent args)
+    {
+        string desc = "";
+        if (!comp.Infinite)
+            desc = $"event-item-dispenser-examine-finite{(comp.CanManuallyDispose ? "-manualdispose" : "")}{(comp.Limit == 1 ? "-single" : "")}";
+        else
+        {
+            desc = $"event-item-dispenser-examine-infinite{(comp.AutoDispose ? "-autodispose" : "")}{(comp.CanManuallyDispose ? "-manualdispose" : "")}{(comp.Limit == 1 ? "-single" : "")}";
+        }
+        int remaining = GetRemaining(args.Examiner, comp);
+
+        args.PushMarkup(
+            Loc.GetString(
+                "event-item-dispenser-item-name",
+                ("itemName", _loc.GetEntityData(comp.DispensingPrototype).Name)), 1);
+        args.PushMarkup(
+            Loc.GetString(
+                desc,
+                ("remaining", remaining),
+                ("limit", comp.Limit),
+                ("noLimit", comp.Limit <= 0) // this is getting ridiculous
+                ), 0);
+    }
+
+    private void OnInteractUsing(EntityUid uid, EventItemDispenserComponent comp, InteractUsingEvent args)
+    {
+        EntityUid user = args.User;
+        EntityUid item = args.Used;
+
+        if (CanOpenUI(user))
+        {
+            var uicomp = Comp<UserInterfaceComponent>(uid);
+            string newProto = MetaData(item).EntityPrototype?.ID ?? comp.DispensingPrototype;
+            if(_ui.TryOpenUi((uid, uicomp), EventItemDispenserUiKey.Key, user))
+                _ui.ServerSendUiMessage((uid, uicomp), EventItemDispenserUiKey.Key, new EventItemDispenserNewProtoBoundUserInterfaceMessage(newProto), args.User);
+            return;
+        }
+        if( comp.CanManuallyDispose &&
+            TryComp<EventDispensedComponent>(item, out var dispensed) &&
+            dispensed.ItemOwner == user &&
+            dispensed.Dispenser == comp.Owner)
+        {
+            Recycle(item, comp, false);
+            PopupRemaining(user, comp);
+            _audio.PlayPvs(comp.ManualDisposeSound, uid);
+        }
+    }
+
+    private void OnActivateInWorld(EntityUid uid, EventItemDispenserComponent comp, ActivateInWorldEvent args)
+    {
+        if(Deleted(_hands.GetActiveItem(args.User)))
+            DispenseRequest(uid, args.User, comp);
+    }
+
+    private void DispenseRequest(EntityUid uid, EntityUid user, EventItemDispenserComponent comp)
+    {
+        if (CanOpenUI(user))
+        {
+            var uicomp = Comp<UserInterfaceComponent>(uid);
+            _ui.TryToggleUi((uid, uicomp), EventItemDispenserUiKey.Key, user);
+            return;
+        }
+        PruneItemList(user, comp);
+        var items = comp.dispensedItems[user];
+        comp.dispensedItemsAmount.TryGetValue(user, out int allTimeAmount);
+
+        if (comp.Limit > 0)
+        {
+            if (!comp.Infinite && allTimeAmount >= comp.Limit) // no fancy bluespace disposal shit if dispenser is meant to be finite.
+            {
+                _audio.PlayPvs(comp.FailSound, uid);
+                _popup.PopupEntity(_loc.GetString("event-item-dispenser-out-of-stock"), uid, user);
+                return;
+            }
+
+            if (items.Count >= comp.Limit)
+            {
+                if (comp.AutoDispose)
+                    DeleteOne(user, comp);
+                else
+                {
+                    _audio.PlayPvs(comp.FailSound, uid);
+                    _popup.PopupEntity(_loc.GetString("event-item-dispenser-limit-reached"), uid, user);
+                    return;
+                }
+            }
+        }
+        Dispense(user, comp);
+    }
+
+    /// <summary>
+    /// Used to delete an oldest item when trying to dispense over limit.
+    /// Does not update the dispensedItems dict, so calling it multiple times will not work.
+    /// </summary>
+    private void DeleteOne(EntityUid owner, EventItemDispenserComponent comp)
+    {
+        var items = comp.dispensedItems[owner];
+        if (items.Count > 0)
+            Recycle(items.First(), comp);
+    }
+
+    private void DeleteAll(EntityUid uid, EventItemDispenserComponent comp)
+    {
+        foreach (var items in comp.dispensedItems.Values)
+        {
+            foreach (var item in items)
+            {
+                if (!TerminatingOrDeleted(item)) // do i have to?
+                {
+                    Recycle(item, comp, false); // no fancy effects
+                } // "{{{{}}}}" is non-negotiable
+            }
+        }
+    }
+
+    private void ReleaseAll(EntityUid dispenser, EventItemDispenserComponent comp) 
+    {
+        foreach (var items in comp.dispensedItems.Values)
+        {
+            foreach (var item in items)
+            {
+                if (!TerminatingOrDeleted(item))
+                {
+                    // not clearing dicts because this is only called immediately prior dispenser comp deletion
+                    RemComp<EventDispensedComponent>(item);
+                } // "{{{{}}}}" is non-negotiable
+            }
+        }
+    }
+
+    private void Recycle(EntityUid item, EventItemDispenserComponent comp, bool replace = true)
+    {
+        if(TryComp<EventDispensedComponent>(item, out var itemcomp))
+        {
+            DebugTools.Assert(comp.Owner == itemcomp.Dispenser, "Attempted to recycle dispensed item in wrong dispenser.");
+            comp.dispensedItemsAmount[itemcomp.ItemOwner]--;
+            //comp.dispensedItems[itemcomp.ItemOwner].Remove(item); // fucks up foreach loops
+            DebugTools.Assert(comp.dispensedItemsAmount[itemcomp.ItemOwner] >= 0, "EventItemDispenser ended up with negative total items dispensed.");
+            if (comp.ReplaceDisposedItems && replace)
+            {
+                var mapPos = _transform.ToMapCoordinates(new Robust.Shared.Map.EntityCoordinates(item, default));
+                Spawn(comp.DisposedReplacement, mapPos);
+            }
+
+            Del(item);
+        }
+    }
+
+    /// <summary>
+    /// This hot mess does a lot of things at once:
+    ///     * Spawn and configure the item
+    ///       * Raise ItemPurchasedEvent on the item just in case
+    ///       * Add and configure EventDispensedComponent, used for easier manual disposals (see <see cref="OnInteractUsing(EntityUid, EventItemDispenserComponent, InteractUsingEvent)"/>)
+    ///     * Keep track on how many items there are
+    ///     * Put said item into user's hands
+    ///     * Play a sound
+    ///
+    /// In short: this is stupid and ugly. TODO fix this. // oh you sweet summer child
+    /// </summary>
+    /// <param name="user"></param>
+    /// <param name="comp"></param>
+    private void Dispense(EntityUid user, EventItemDispenserComponent comp)
+    {
+        var mapPos = _transform.ToMapCoordinates(new Robust.Shared.Map.EntityCoordinates(user, default));
+        var item = Spawn(comp.DispensingPrototype, mapPos);
+        var ev = new ItemPurchasedEvent(user);
+        RaiseLocalEvent(item, ref ev); // erectin' a vendomat
+        var dispensedComp = AddComp<EventDispensedComponent>(item);
+        dispensedComp.Dispenser = comp.Owner;
+        dispensedComp.ItemOwner = user;
+
+        comp.dispensedItems[user].Add(item);
+
+        comp.dispensedItemsAmount.TryGetValue(user, out int amount);
+        comp.dispensedItemsAmount[user] = amount + 1;
+
+        _hands.TryPickup(user, item);
+        PopupRemaining(user, comp);
+        _audio.PlayPvs(comp.DispenseSound, comp.Owner);
+    }
+
+    private void PopupRemaining(EntityUid user, EventItemDispenserComponent comp)
+    {
+        int remaining = GetRemaining(user, comp);
+        if (comp.Infinite)
+            remaining = comp.Limit - remaining; // to instead indicate how much items we have already taken
+        _popup.PopupEntity($"{remaining}/{comp.Limit}", comp.Owner, user);
+    }
+
+    private string ValidateProto(string proto, string backup)
+    {
+        return _proto.HasIndex<EntityPrototype>(proto) ? proto : backup;
+    }
+
+    private bool CanOpenUI(EntityUid user)
+    {
+        var adminData = _admeme.GetAdminData(user);
+        return adminData != null && adminData.CanAdminPlace() &&
+            HasComp<GhostComponent>(user);
+            //MetaData(user).EntityPrototype?.ID == GameTicker.AdminObserverPrototypeName;
+
+    }
+
+    /// <summary>
+    /// Self-explanatory.
+    /// </summary>
+    private int GetRemaining(EntityUid user, EventItemDispenserComponent comp)
+    {
+        if (comp.Limit <= 0)
+            return 9001;
+        if (comp.Infinite)
+        {
+            PruneItemList(user, comp);
+            return comp.dispensedItems.ContainsKey(user) ? comp.Limit - comp.dispensedItems[user].Count : comp.Limit;
+        }
+        else
+            return comp.dispensedItemsAmount.ContainsKey(user) ? comp.Limit - comp.dispensedItemsAmount[user] : comp.Limit;
+
+    }
+    private void PruneItemList(EntityUid user, EventItemDispenserComponent comp)
+    {
+        comp.dispensedItems[user] = comp.dispensedItems.GetOrNew(user).Where(item => !TerminatingOrDeleted(item)).ToList();
+    }
+
+    // i refuse to delete my beloved
+    ///// <summary>
+    ///// my beloved
+    ///// </summary>
+    //private string GetPlural(int n, string one, string two, string five)
+    //{
+    //    n = Math.Abs(n);
+    //    n %= 100;
+    //    if (n >= 5 && n <= 20)
+    //    {
+    //        return five;
+    //    }
+    //    n %= 10;
+    //    if (n == 1)
+    //    {
+    //        return one;
+    //    }
+    //    if (n >= 2 && n <= 4)
+    //    {
+    //        return two;
+    //    }
+    //    return five;
+    //}
+}
\ No newline at end of file
diff --git a/Content.Shared/Weapons/Ranged/Events/TakeAmmoEvent.cs b/Content.Shared/Weapons/Ranged/Events/TakeAmmoEvent.cs
index 50cd7871d62..49fd174a21e 100644
--- a/Content.Shared/Weapons/Ranged/Events/TakeAmmoEvent.cs
+++ b/Content.Shared/Weapons/Ranged/Events/TakeAmmoEvent.cs
@@ -29,3 +29,13 @@ public TakeAmmoEvent(int shots, List<(EntityUid? Entity, IShootable Shootable)>
         User = user;
     }
 }
+
+// Cats start edit
+/// <summary>
+/// Raised on BallisticAmmoComponents to force them to generate their ammo as actual entities.
+/// </summary>
+public sealed class ForceSpawnAmmoEvent : EntityEventArgs
+{
+
+}
+// Cats end edit
diff --git a/Content.Shared/Weapons/Ranged/Systems/SharedGunSystem.Ballistic.cs b/Content.Shared/Weapons/Ranged/Systems/SharedGunSystem.Ballistic.cs
index 9ef5cbd7028..8d1ec5fdeec 100644
--- a/Content.Shared/Weapons/Ranged/Systems/SharedGunSystem.Ballistic.cs
+++ b/Content.Shared/Weapons/Ranged/Systems/SharedGunSystem.Ballistic.cs
@@ -21,6 +21,8 @@ protected virtual void InitializeBallistic()
         SubscribeLocalEvent<BallisticAmmoProviderComponent, ComponentInit>(OnBallisticInit);
         SubscribeLocalEvent<BallisticAmmoProviderComponent, MapInitEvent>(OnBallisticMapInit);
         SubscribeLocalEvent<BallisticAmmoProviderComponent, TakeAmmoEvent>(OnBallisticTakeAmmo);
+        SubscribeLocalEvent<BallisticAmmoProviderComponent, ForceSpawnAmmoEvent>(OnForceSpawnAmmo); // Cats EDIT
+
         SubscribeLocalEvent<BallisticAmmoProviderComponent, GetAmmoCountEvent>(OnBallisticAmmoCount);
 
         SubscribeLocalEvent<BallisticAmmoProviderComponent, ExaminedEvent>(OnBallisticExamine);
@@ -263,6 +265,20 @@ private void OnBallisticTakeAmmo(EntityUid uid, BallisticAmmoProviderComponent c
         Dirty(uid, component);
     }
 
+    // CATS EDIT START
+    private void OnForceSpawnAmmo(EntityUid uid, BallisticAmmoProviderComponent component, ForceSpawnAmmoEvent args)
+    {
+        while(component.UnspawnedCount > 0)
+        {
+            var ent = Spawn(component.Proto, MapCoordinates.Nullspace);
+            component.Entities.Add(ent);
+            Containers.Insert(ent, component.Container);
+            component.UnspawnedCount--;
+        }
+        Dirty(uid, component);
+    }
+    // CATS EDIT END
+
     private void OnBallisticAmmoCount(EntityUid uid, BallisticAmmoProviderComponent component, ref GetAmmoCountEvent args)
     {
         args.Count = GetBallisticShots(component);
diff --git a/Content.Shared/_Cats/Event/EventEntityDispenserComponent.cs b/Content.Shared/_Cats/Event/EventEntityDispenserComponent.cs
new file mode 100644
index 00000000000..a4cbacdaba9
--- /dev/null
+++ b/Content.Shared/_Cats/Event/EventEntityDispenserComponent.cs
@@ -0,0 +1,119 @@
+using Robust.Shared.Audio;
+using Robust.Shared.GameStates;
+using Robust.Shared.Prototypes;
+using Robust.Shared.Serialization;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Content.Shared._Cats.Event;
+
+[RegisterComponent, AutoGenerateComponentState(true), NetworkedComponent]
+public sealed partial class EventItemDispenserComponent : Component
+{
+
+    [DataField("dispensing"), AutoNetworkedField]
+    public EntProtoId DispensingPrototype;
+
+    [DataField, AutoNetworkedField]
+    public bool CanManuallyDispose = true;
+
+    [DataField, AutoNetworkedField]
+    public bool AutoDispose = true;
+
+    [DataField, AutoNetworkedField]
+    public bool Infinite = true;
+
+    [DataField, AutoNetworkedField]
+    public int Limit = 3;
+
+    [DataField, AutoNetworkedField]
+    public bool AutoCleanUp = true;
+
+    [DataField, AutoNetworkedField]
+    public SoundSpecifier DispenseSound = new SoundPathSpecifier("/Audio/Machines/machine_vend.ogg");
+
+    [DataField, AutoNetworkedField]
+    public SoundSpecifier FailSound = new SoundPathSpecifier("/Audio/Machines/custom_deny.ogg");
+
+    [DataField, AutoNetworkedField]
+    public SoundSpecifier ManualDisposeSound = new SoundCollectionSpecifier("trashBagRustle");
+
+    [DataField, AutoNetworkedField]
+    public bool ReplaceDisposedItems = true;
+    [DataField, AutoNetworkedField]
+    public EntProtoId DisposedReplacement = "EffectTeslaSparksSilent";
+
+    [DataField, AutoNetworkedField]
+    public float ItemPreviewScale = 0f;
+
+    /// <summary>
+    /// Stores Lists with all (currently existing) items.
+    /// Owners' Uids used as keys.
+    /// </summary>
+    [ViewVariables]
+    public Dictionary<EntityUid, List<EntityUid>> dispensedItems = new();
+
+    /// <summary>
+    /// Stores the amount of items spawned by each person in this dispenser's lifetime.
+    /// Owners' Uids used as keys.
+    /// </summary>
+    [ViewVariables]
+    public Dictionary<EntityUid, int> dispensedItemsAmount = new();
+
+}
+
+
+/// <summary>
+/// Stores relevant info about who dispensed this item to avoid having to look for it in the dispensedItems dict.
+/// </summary>
+[RegisterComponent]
+public sealed partial class EventDispensedComponent : Component
+{
+    /// <summary>
+    /// The person who took the item.
+    /// </summary>
+    [ViewVariables]
+    public EntityUid ItemOwner;
+    /// <summary>
+    /// The dispenser which dispensed (duh) the item.
+    /// </summary>
+    [ViewVariables]
+    public EntityUid Dispenser;
+    /// <summary>
+    /// 
+    /// </summary>
+    [ViewVariables]
+    public List<EntityUid> Slaved = new();
+}
+
+
+[Serializable, NetSerializable]
+public enum EventItemDispenserUiKey : byte
+{
+    Key,
+}
+
+
+[Serializable, NetSerializable]
+public class EventItemDispenserNewConfigBoundUserInterfaceMessage : BoundUserInterfaceMessage
+{
+    public string DispensingPrototype = "FoodBanana";
+    public bool CanManuallyDispose;
+    public bool AutoDispose;
+    public bool Infinite;
+    public int Limit;
+    public bool AutoCleanUp;
+    public bool ReplaceDisposedItems;
+    public string DisposedReplacement = "EffectTeslaSparksSilent";
+}
+
+
+[Serializable, NetSerializable]
+public class EventItemDispenserNewProtoBoundUserInterfaceMessage : BoundUserInterfaceMessage
+{
+    public string DispensingPrototype = "FoodBanana";
+    public EventItemDispenserNewProtoBoundUserInterfaceMessage(string proto) { DispensingPrototype = proto; }
+}
\ No newline at end of file
diff --git a/Content.Shared/_Cats/Event/SharedEventEntityDispenserSystem.cs b/Content.Shared/_Cats/Event/SharedEventEntityDispenserSystem.cs
new file mode 100644
index 00000000000..0ec10143356
--- /dev/null
+++ b/Content.Shared/_Cats/Event/SharedEventEntityDispenserSystem.cs
@@ -0,0 +1,14 @@
+using Content.Shared.Hands.EntitySystems;
+using Content.Shared.Interaction;
+using Robust.Shared.Utility;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Content.Shared._Cats.Event;
+
+public abstract class SharedEventItemDispenserSystem : EntitySystem {}
+// Spawning logic is handled server-side, anything cosmetic is clientside.
+// Got nothing to stuff in here.
\ No newline at end of file
diff --git a/Resources/Locale/ru-RU/_Cats/Event/eventItemDispenser.ftl b/Resources/Locale/ru-RU/_Cats/Event/eventItemDispenser.ftl
new file mode 100644
index 00000000000..f647c5de382
--- /dev/null
+++ b/Resources/Locale/ru-RU/_Cats/Event/eventItemDispenser.ftl
@@ -0,0 +1,84 @@
+-event-item-dispenser-out-of-stock = Предметы кончились!
+-event-item-dispenser-limit-reached = Лимит достигнут!
+-event-item-dispenser-unlimited = [color=yellow]сколько угодно[/color] предметов
+# For some reason, after the {-item-plural()} fluent fails to insert {$l}, despite it being passed, but successfully inserts {$limit}, even though
+# it is "global" and should fail the same way it fails to insert {$remaining}.
+-event-item-dispenser-infinite-count = ещё [color=yellow]{ $r }[/color] {-item-plural(count:$r)} (из [color=yellow]{ $limit }[/color])
+-item-plural = {$count ->
+    [one] предмет
+    [few] предмета
+    *[many] предметов
+}
+-item-plural-remain = {$count ->
+    [one] остался
+    *[few] осталось
+}
+event-item-dispenser-item-name = Выдаёт нечто под названием "[color=violet]{ $itemName }[/color]" 
+event-item-dispenser-examine-infinite = Я могу взять {$noLimit -> 
+    [true]   { -event-item-dispenser-unlimited }!
+    *[other] { -event-item-dispenser-infinite-count(r: $remaining, l: $limit) }.
+}
+event-item-dispenser-examine-infinite-autodispose = {$noLimit -> 
+    [true]   Я могу взять { -event-item-dispenser-unlimited }!
+    *[other] Я могу взять { -event-item-dispenser-infinite-count(r: $remaining, l: $limit) }, прежде чем самый старый предмет пропадёт.
+}
+event-item-dispenser-examine-infinite-autodispose-manualdispose = {$noLimit -> 
+    [true]   Я могу взять { -event-item-dispenser-unlimited }! Если что, я могу вернуть их здесь.
+    *[other] Я могу взять { -event-item-dispenser-infinite-count(r: $remaining, l: $limit) }, прежде чем самый старый предмет пропадёт. Если что, я могу вернуть их здесь, чтобы получить новые.
+}
+event-item-dispenser-examine-infinite-manualdispose= {$noLimit ->
+    [true]   Я могу взять { -event-item-dispenser-unlimited }! Если что, я могу вернуть их здесь.
+    *[other] Я могу взять { -event-item-dispenser-infinite-count(r: $remaining, l: $limit) }, прежде чем мне придётся их вернуть, чтобы взять новые.
+}
+event-item-dispenser-examine-infinite-single = {$remaining ->
+    [1] Внутри только [color=yellow]один[/color] предмет.
+    *[0] Внутри [color=yellow]пусто[/color].
+}
+event-item-dispenser-examine-infinite-autodispose-single = {$remaining ->
+    [1] Я могу здесь взять только [color=yellow]один[/color] предмет. Если я возьму второй, первый пропадёт.
+    *[0] Если я возьму здесь [color=yellow]новый[/color] предмет, старый пропадёт.
+}
+event-item-dispenser-examine-infinite-autodispose-manualdispose-single = {$remaining ->
+    [1] Я могу здесь взять только [color=yellow]один[/color] предмет. Если что, я смогу его вернуть, чтобы получить новый.
+    *[0] Если я возьму здесь [color=yellow]новый[/color] предмет, старый пропадёт. А ещё я могу вернуть здесь старый предмет, чтобы получить новый.
+}
+event-item-dispenser-examine-infinite-manualdispose-single = {$remaining ->
+    [1] Я могу здесь взять только [color=yellow]один[/color] предмет. Если что, я смогу его вернуть.
+    *[0] Внутри [color=yellow]пусто[/color], но я могу вернуть здесь старый предмет, чтобы получить новый.
+}
+# For some reason, after the {-item-plural()} fluent fails to insert {$l}, despite it being passed, but successfully inserts {$limit}, even though
+# it is "global" and should fail the same way it fails to insert {$remaining}.
+-event-item-dispenser-finite-count = [color=yellow]{$r}[/color] { -item-plural(count: $remaining)} (из [color=yellow]{$limit}[/color])
+event-item-dispenser-examine-finite = {$noLimit ->
+    [true]   Я могу взять { -event-item-dispenser-unlimited }!
+    *[false] Внутри {-item-plural-remain(count: $remaining)} { -event-item-dispenser-finite-count(r:$remaining, l:$limit) }.
+}
+event-item-dispenser-examine-finite-manualdispose = Внутри {-item-plural-remain(count: $remaining)} {$noLimit ->
+    [true]   Я могу взять { -event-item-dispenser-unlimited }! Если что, я могу их вернуть.
+    *[false] Внутри {-item-plural-remain(count: $remaining)} { -event-item-dispenser-finite-count(r:$remaining, l:$limit) } Если что, я могу их вернуть, чтобы получить новые.
+}11
+event-item-dispenser-examine-finite-single = {$remaining ->
+    [1] Внутри только [color=yellow]один[/color] предмет.
+    *[0] Внутри [color=yellow]пусто[/color].
+}
+event-item-dispenser-examine-finite-manualdispose-single = {$remaining ->
+    [1] Внутри только [color=yellow]один[/color] предмет. Если что, я смогу его вернуть, чтобы получить новый.
+    *[0] Внутри [color=yellow]пусто[/color], но я могу вернуть здесь старый предмет, чтобы получить новый.
+}
+eventitemdispenser-configwindow-dispensingprototype-tooltip = Прототип предмета, который будет выдаваться игроку при клике. Когда вы в aghost: кликните предметом по раздатчику, чтобы скопировать его прототип сюда.
+eventitemdispenser-configwindow-autodispose-tooltip = При попытке взять предмет сверх установленного лимита, удаляет самый старый предмет. Не имеет эффекта на раздатчиках с конечным запасом!
+eventitemdispenser-configwindow-infinite-tooltip = Раздатчик с конечным запасом отслеживает, сколько предметов взял игрок и не даёт взять сверх лимита. Бесконечный раздатчик в своём подсчёте не учитывает удалённые предметы.
+eventitemdispenser-configwindow-limit-tooltip = Максимальное количество предметов, которое может взять каждый игрок из этого раздатчика. Ноль отключает лимит, будьте осторожны!
+eventitemdispenser-configwindow-canmanuallydispose-tooltip = Если да, то при клике на раздатчик выданным предметом удаляет его, "возвращая" в раздатчик. Свойства предмета (напр. батарейка егана) не переносятся на следующий выдаваемый предмет.
+eventitemdispenser-configwindow-replacedisposeditems-tooltip = При автоматическом удалении лишних предметов заменять их на данный прототип. Не имеет эффекта на раздатчиках без автоудаления излишка!
+eventitemdispenser-configwindow-disposedreplacement-tooltip = Прототип предмета, на который будет заменён удаляемый лишний предмет. Рекомендуется указать либо прототип какого-нибудь мусора, либо прототип эффекта. [color=yellow]Не имеет эффекта на раздатчиках без автоудаления излишка![/color]
+eventitemdispenser-configwindow-autocleanup-tooltip = Если да, то все предметы, выданные этим раздатчиком, будут удалены вместе с этим раздатчиком. (На самом деле вместе с компонентом EventItemDispenser раздатчика)
+eventitemdispenser-configwindow-title = Erectin' a dispenser
+eventitemdispenser-configwindow-dispensingprototype = Прототип предмета
+eventitemdispenser-configwindow-autodispose = Автоматически удалять излишек?
+eventitemdispenser-configwindow-canmanuallydispose = Можно ли вручную удалить предмет?
+eventitemdispenser-configwindow-infinite = Бесконечно восполняемый запас
+eventitemdispenser-configwindow-limit = Лимит предметов
+eventitemdispenser-configwindow-replacedisposeditems = Заменять автоматически удалённые предметы?
+eventitemdispenser-configwindow-disposedreplacement = Прототип замены
+eventitemdispenser-configwindow-autocleanup = Автоматическая чистка при удалении раздатчика
\ No newline at end of file
diff --git a/Resources/Prototypes/_SpaceCats/Entities/Effects/effects.yml b/Resources/Prototypes/_SpaceCats/Entities/Effects/effects.yml
new file mode 100644
index 00000000000..6ca06f19adc
--- /dev/null
+++ b/Resources/Prototypes/_SpaceCats/Entities/Effects/effects.yml
@@ -0,0 +1,19 @@
+- type: entity
+  id: EffectTeslaSparksSilent
+  categories: [ HideSpawnMenu ]
+  components:
+  - type: TimedDespawn
+    lifetime: 0.5
+  - type: Sprite
+    drawdepth: Effects
+    noRot: true
+    layers:
+    - shader: unshaded
+      map: ["enum.EffectLayers.Unshaded"]
+      sprite: Effects/atmospherics.rsi
+      state: frezon_old
+  - type: EffectVisuals
+  - type: Tag
+    tags:
+    - HideContextMenu
+  - type: AnimationPlayer
\ No newline at end of file
diff --git a/Resources/Prototypes/_SpaceCats/Entities/Structures/Misc/EventDispensers.yml b/Resources/Prototypes/_SpaceCats/Entities/Structures/Misc/EventDispensers.yml
new file mode 100644
index 00000000000..7b33597bea7
--- /dev/null
+++ b/Resources/Prototypes/_SpaceCats/Entities/Structures/Misc/EventDispensers.yml
@@ -0,0 +1,62 @@
+- type: entity
+  abstract: true
+  parent: BaseStructure
+  id: BaseEventItemDispenser
+  components:
+  - type: Sprite
+    sprite: _SpaceCats/Structures/Misc/EventItemDispenser.rsi
+    layers:
+    - state: base
+      offset: 0, 0.0625
+    - state: base_glow
+      shader: unshaded
+      offset: 0, 0.0625
+    - state: lamp_glow
+      shader: unshaded
+      offset: 0, 0.0625
+    - state: hands
+      offset: 0, 0.0625
+    - map: ["enum.EventItemDispenserVisualLayers.ItemPreview"]
+      shader: FlickerHologram
+      offset: 0, 0.25
+  - type: InteractionOutline
+  - type: Physics
+    bodyType: Static
+  - type: Transform
+    noRot: true
+  - type: Fixtures
+    fixtures:
+      fix1:
+        shape:
+          !type:PhysShapeAabb
+          bounds: "-0.45,-0.45,0.45,0.45"
+        density: 190
+        mask:
+        - MachineMask
+        layer:
+        - MachineLayer
+  - type: UserInterface
+    interfaces:
+        enum.EventItemDispenserUiKey.Key:
+          type: EventItemDispenserConfigBoundUserInterface
+          interactionRange: -1
+  - type: EventItemDispenser
+    dispensing: FoodBanana
+
+- type: entity
+  name: Fun dispenser
+  parent: BaseEventItemDispenser
+  id: EventExGrenadeDispenser
+  components:
+  - type: EventItemDispenser
+    dispensing: GrenadeDummy
+
+- type: entity
+  name: Limited fun dispenser
+  parent: BaseEventItemDispenser
+  id: BaseEventItemDispenserFinite
+  components:
+  - type: EventItemDispenser
+    dispensing: Stunbaton
+    limit: 2
+    infinite: false
\ No newline at end of file
diff --git a/Resources/Prototypes/_SpaceCats/Shaders/shaders.yml b/Resources/Prototypes/_SpaceCats/Shaders/shaders.yml
index fd5bd1324ad..fb781783fce 100644
--- a/Resources/Prototypes/_SpaceCats/Shaders/shaders.yml
+++ b/Resources/Prototypes/_SpaceCats/Shaders/shaders.yml
@@ -1,4 +1,10 @@
 - type: shader
   id: NightVision
   kind: source
-  path: "/Textures/_SpaceCats/Shaders/nightvision.swsl"
\ No newline at end of file
+  path: "/Textures/_SpaceCats/Shaders/nightvision.swsl"
+
+- type: shader
+  id: FlickerHologram
+  kind: source
+  path: "/Textures/_SpaceCats/Shaders/flickerhologram.swsl"
+  light_mode: unshaded
\ No newline at end of file
diff --git a/Resources/Textures/_SpaceCats/Shaders/flickerhologram.swsl b/Resources/Textures/_SpaceCats/Shaders/flickerhologram.swsl
new file mode 100644
index 00000000000..afb6218a202
--- /dev/null
+++ b/Resources/Textures/_SpaceCats/Shaders/flickerhologram.swsl
@@ -0,0 +1,67 @@
+//
+// https://gamedev.stackexchange.com/a/59808
+//
+//   Author: sam hocevar
+// Answered: Jul 27, 2013 at 13:33
+//  License: CC BY-SA 3.0
+//
+
+highp vec3 rgb2hsv(highp vec3 c)
+{
+    highp vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
+    highp vec4 p = mix(vec4(c.bg, K.wz), vec4(c.gb, K.xy), step(c.b, c.g));
+    highp vec4 q = mix(vec4(p.xyw, c.r), vec4(c.r, p.yzx), step(p.x, c.r));
+
+    highp float d = q.x - min(q.w, q.y);
+    /* float e = 1.0e-10; */
+    highp float e = 0.0000000001;
+    return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
+}
+
+highp vec3 hsv2rgb(highp vec3 c)
+{
+    highp vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+    highp vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
+    return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
+}
+
+highp float rng(highp vec2 co){
+    return fract(sin(dot(co.xy ,vec2(12.9898,78.233))) * 43758.5453);
+}
+
+highp vec3 blend(highp vec3 base, highp vec3 color, highp float factor){
+	return base+(color-base)*factor;
+}
+
+// No args, no customization
+// quick and simple okay-ish looking shader because i don't like the deltaV one.
+// todo make an excuse to use this somewhere besides event dispensers so i have to make it more customizable (at least its color)
+void fragment() {
+
+	highp float hue = 0.48;
+	highp float hue2 = hue-0.01;
+
+	// absolutely unreadable, introduces random noise in the X coord of the UV, seeded by Y
+	// produces scanline-like effect, with each line of pixels being randomly displaced left or right
+	// makes the item jitter a bit
+	highp float dispfloat = rng(vec2(UV.y*TIME, 0));
+
+	//highp vec2 displacement = vec2(rng(vec2(UV.y*TIME, 0))*length(TEXTURE_PIXEL_SIZE)*0.25);
+
+    highp vec4 tex = zTexture(UV + vec2(dispfloat*TEXTURE_PIXEL_SIZE.x*0.5, 0));
+
+	highp vec3 col = rgb2hsv(tex.rgb);
+	col.x = hue;
+	col.z = (log(col.z)+4)/4; // increase the value in hsv color, helps with highlighting detail
+
+	// this produces a color which randomly flashes from hue2 (at max value) to white
+	// mixed in with sprite color down below
+	highp vec3 col2 = hsv2rgb(vec3(hue2, rng(vec2(TIME*0.001, 0))*0.4+0.6, 1.0));
+	col = hsv2rgb(col);
+
+	COLOR = vec4(mix(col, col2, 0.3), max(tex.w*(sin(TIME * sin(TIME)))*0.25, 0)+0.45*tex.w);
+	// another scanline-like effect, but with transparensy this time
+	// "*=" instead of proper construction because it's an afterthought
+	COLOR.w *= rng(vec2(0, 1.09248882*TIME*UV.y))*0.5+0.5;
+	lightSample = vec3(1.0);
+}
\ No newline at end of file
diff --git a/Resources/Textures/_SpaceCats/Structures/Misc/EventItemDispenser.rsi/base.png b/Resources/Textures/_SpaceCats/Structures/Misc/EventItemDispenser.rsi/base.png
new file mode 100644
index 00000000000..3541ed52483
Binary files /dev/null and b/Resources/Textures/_SpaceCats/Structures/Misc/EventItemDispenser.rsi/base.png differ
diff --git a/Resources/Textures/_SpaceCats/Structures/Misc/EventItemDispenser.rsi/base_glow.png b/Resources/Textures/_SpaceCats/Structures/Misc/EventItemDispenser.rsi/base_glow.png
new file mode 100644
index 00000000000..14edd802f88
Binary files /dev/null and b/Resources/Textures/_SpaceCats/Structures/Misc/EventItemDispenser.rsi/base_glow.png differ
diff --git a/Resources/Textures/_SpaceCats/Structures/Misc/EventItemDispenser.rsi/hands.png b/Resources/Textures/_SpaceCats/Structures/Misc/EventItemDispenser.rsi/hands.png
new file mode 100644
index 00000000000..b51181a9fb3
Binary files /dev/null and b/Resources/Textures/_SpaceCats/Structures/Misc/EventItemDispenser.rsi/hands.png differ
diff --git a/Resources/Textures/_SpaceCats/Structures/Misc/EventItemDispenser.rsi/lamp_glow.png b/Resources/Textures/_SpaceCats/Structures/Misc/EventItemDispenser.rsi/lamp_glow.png
new file mode 100644
index 00000000000..8e583906448
Binary files /dev/null and b/Resources/Textures/_SpaceCats/Structures/Misc/EventItemDispenser.rsi/lamp_glow.png differ
diff --git a/Resources/Textures/_SpaceCats/Structures/Misc/EventItemDispenser.rsi/meta.json b/Resources/Textures/_SpaceCats/Structures/Misc/EventItemDispenser.rsi/meta.json
new file mode 100644
index 00000000000..eff9d934a4e
--- /dev/null
+++ b/Resources/Textures/_SpaceCats/Structures/Misc/EventItemDispenser.rsi/meta.json
@@ -0,0 +1,51 @@
+{
+  "version": 1,
+  "license": "CC-BY-SA-4.0",
+  "copyright": "Made by Gersoon",
+  "size": {
+    "x": 32,
+    "y": 32
+  },
+  "states": [
+    {
+      "name": "base"
+    },
+    {
+      "name": "hands",
+      "delays": [
+        [
+          0.1,
+          0.1,
+          0.1,
+          0.1
+        ]
+      ]
+    },
+    {
+      "name": "lamp_glow",
+      "delays": [
+        [
+          0.1,
+          0.1,
+          0.1,
+          0.1,
+          0.1,
+          0.1
+        ]
+      ]
+    },
+	{
+      "name": "base_glow",
+      "delays": [
+        [
+          0.25,
+          0.1,
+          0.1,
+          0.25,
+          0.1,
+          0.1
+        ]
+      ]
+    }
+  ]
+}