Re-organize all projects (#4166)

Content.Server/Kitchen/Components/JuiceableComponent.cs

@@ -0,0 +1,17 @@
+using Content.Shared.Chemistry.Solution;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Serialization.Manager.Attributes;
+using Robust.Shared.ViewVariables;
+
+namespace Content.Server.Kitchen.Components
+{
+    /// <summary>
+    /// Tag component that denotes an entity as Juiceable
+    /// </summary>
+    [RegisterComponent]
+    public class JuiceableComponent : Component
+    {
+        public override string Name => "Juiceable";
+        [ViewVariables] [DataField("result")] public Solution JuiceResultSolution = new();
+    }
+}

Content.Server/Kitchen/Components/KitchenSpikeComponent.cs

@@ -0,0 +1,178 @@
+#nullable enable
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using Content.Server.Act;
+using Content.Server.Chat.Managers;
+using Content.Server.DoAfter;
+using Content.Server.Notification;
+using Content.Shared.DragDrop;
+using Content.Shared.Interaction;
+using Content.Shared.Kitchen.Components;
+using Content.Shared.MobState;
+using Content.Shared.Notification;
+using Content.Shared.Nutrition.Components;
+using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Localization;
+using Robust.Shared.Player;
+
+namespace Content.Server.Kitchen.Components
+{
+    [RegisterComponent]
+    [ComponentReference(typeof(IActivate))]
+    public class KitchenSpikeComponent : SharedKitchenSpikeComponent, IActivate, ISuicideAct
+    {
+        private int _meatParts;
+        private string? _meatPrototype;
+        private string _meatSource1p = "?";
+        private string _meatSource0 = "?";
+        private string _meatName = "?";
+
+        private List<EntityUid> _beingButchered = new();
+
+        void IActivate.Activate(ActivateEventArgs eventArgs)
+        {
+            SpriteComponent? sprite;
+
+            if (_meatParts == 0)
+            {
+                return;
+            }
+            _meatParts--;
+
+            if (!string.IsNullOrEmpty(_meatPrototype))
+            {
+                var meat = Owner.EntityManager.SpawnEntity(_meatPrototype, Owner.Transform.Coordinates);
+                if (meat != null)
+                {
+                    meat.Name = _meatName;
+                }
+            }
+
+            if (_meatParts != 0)
+            {
+                eventArgs.User.PopupMessage(_meatSource1p);
+            }
+            else
+            {
+                if (Owner.TryGetComponent(out sprite))
+                {
+                    sprite.LayerSetState(0, "spike");
+                }
+
+                eventArgs.User.PopupMessage(_meatSource0);
+            }
+
+            return;
+
+        }
+
+        public override bool DragDropOn(DragDropEvent eventArgs)
+        {
+            TrySpike(eventArgs.Dragged, eventArgs.User);
+            return true;
+        }
+
+        private bool Spikeable(IEntity user, IEntity victim, [NotNullWhen(true)] out SharedButcherableComponent? butcherable)
+        {
+            butcherable = null;
+
+            if (_meatParts > 0)
+            {
+                Owner.PopupMessage(user, Loc.GetString("comp-kitchen-spike-deny-collect", ("this", Owner)));
+                return false;
+            }
+
+            if (!victim.TryGetComponent(out butcherable))
+            {
+                Owner.PopupMessage(user, Loc.GetString("comp-kitchen-spike-deny-butcher", ("victim", victim), ("this", Owner)));
+                return false;
+            }
+
+            if (butcherable.MeatPrototype == null)
+                return false;
+
+            return true;
+        }
+
+        public async void TrySpike(IEntity victim, IEntity user)
+        {
+            var victimUid = victim.Uid;
+            if (_beingButchered.Contains(victimUid)) return;
+
+            SharedButcherableComponent? butcherable;
+
+            if (!Spikeable(user, victim, out butcherable))
+                return;
+
+            // Prevent dead from being spiked TODO: Maybe remove when rounds can be played and DOT is implemented
+            if (victim.TryGetComponent<IMobStateComponent>(out var state) &&
+                !state.IsDead())
+            {
+                Owner.PopupMessage(user, Loc.GetString("comp-kitchen-spike-deny-not-dead", ("victim", victim)));
+                return;
+            }
+
+            if (user != victim)
+                Owner.PopupMessage(victim, Loc.GetString("comp-kitchen-spike-begin-hook-victim", ("user", user), ("this", Owner)));
+            else
+                Owner.PopupMessage(victim, Loc.GetString("comp-kitchen-spike-begin-hook-self", ("this", Owner)));
+
+            var doAfterSystem = EntitySystem.Get<DoAfterSystem>();
+
+            var doAfterArgs = new DoAfterEventArgs(user, SpikeDelay, default, victim)
+            {
+                BreakOnTargetMove = true,
+                BreakOnUserMove = true,
+                BreakOnDamage = true,
+                BreakOnStun = true,
+                NeedHand = true,
+            };
+
+            _beingButchered.Add(victimUid);
+
+            var result = await doAfterSystem.DoAfter(doAfterArgs);
+
+            _beingButchered.Remove(victimUid);
+
+            if (result == DoAfterStatus.Cancelled)
+                return;
+
+            if (!Spikeable(user, victim, out butcherable))
+                return;
+
+            _meatPrototype = butcherable.MeatPrototype;
+            _meatParts = 5;
+            _meatSource1p = Loc.GetString("comp-kitchen-spike-remove-meat", ("victim", victim));
+            _meatSource0 = Loc.GetString("comp-kitchen-spike-remove-meat-last", ("victim", victim));
+            // TODO: This could stand to be improved somehow, but it'd require Name to be much 'richer' in detail than it presently is.
+            // But Name is RobustToolbox-level, so presumably it'd have to be done in some other way (interface???)
+            _meatName = Loc.GetString("comp-kitchen-spike-meat-name", ("victim", victim));
+
+            // TODO: Visualizer
+            if (Owner.TryGetComponent<SpriteComponent>(out var sprite))
+            {
+                sprite.LayerSetState(0, "spikebloody");
+            }
+
+            Owner.PopupMessageEveryone(Loc.GetString("comp-kitchen-spike-kill", ("user", user), ("victim", victim)));
+            // TODO: Need to be able to leave them on the spike to do DoT, see ss13.
+            victim.Delete();
+
+            if (SpikeSound != null)
+                SoundSystem.Play(Filter.Pvs(Owner), SpikeSound, Owner);
+        }
+
+        SuicideKind ISuicideAct.Suicide(IEntity victim, IChatManager chat)
+        {
+            var othersMessage = Loc.GetString("comp-kitchen-spike-suicide-other", ("victim", victim));
+            victim.PopupMessageOtherClients(othersMessage);
+
+            var selfMessage = Loc.GetString("comp-kitchen-spike-suicide-self");
+            victim.PopupMessage(selfMessage);
+
+            return SuicideKind.Piercing;
+        }
+    }
+}

Content.Server/Kitchen/Components/MicrowaveComponent.cs

@@ -0,0 +1,518 @@
+#nullable enable
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Content.Server.Act;
+using Content.Server.Chat.Managers;
+using Content.Server.Chemistry.Components;
+using Content.Server.Hands.Components;
+using Content.Server.Items;
+using Content.Server.Notification;
+using Content.Server.Power.Components;
+using Content.Server.UserInterface;
+using Content.Shared.Body.Components;
+using Content.Shared.Body.Part;
+using Content.Shared.Chemistry;
+using Content.Shared.Chemistry.Reagent;
+using Content.Shared.Chemistry.Solution;
+using Content.Shared.Chemistry.Solution.Components;
+using Content.Shared.Interaction;
+using Content.Shared.Kitchen;
+using Content.Shared.Kitchen.Components;
+using Content.Shared.Notification;
+using Content.Shared.Power;
+using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Containers;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Localization;
+using Robust.Shared.Player;
+using Robust.Shared.Serialization.Manager.Attributes;
+using Robust.Shared.ViewVariables;
+
+namespace Content.Server.Kitchen.Components
+{
+    [RegisterComponent]
+    [ComponentReference(typeof(IActivate))]
+    public class MicrowaveComponent : SharedMicrowaveComponent, IActivate, IInteractUsing, ISolutionChange, ISuicideAct
+    {
+        [Dependency] private readonly RecipeManager _recipeManager = default!;
+
+        #region YAMLSERIALIZE
+        [DataField("cookTime")]
+        private uint _cookTimeDefault = 5;
+        [DataField("cookTimeMultiplier")]
+        private int _cookTimeMultiplier = 1000; //For upgrades and stuff I guess?
+        [DataField("failureResult")]
+        private string _badRecipeName = "FoodBadRecipe";
+        [DataField("beginCookingSound")]
+        private string _startCookingSound = "/Audio/Machines/microwave_start_beep.ogg";
+        [DataField("foodDoneSound")]
+        private string _cookingCompleteSound = "/Audio/Machines/microwave_done_beep.ogg";
+#endregion
+
+[ViewVariables]
+        private bool _busy = false;
+
+        /// <summary>
+        /// This is a fixed offset of 5.
+        /// The cook times for all recipes should be divisible by 5,with a minimum of 1 second.
+        /// For right now, I don't think any recipe cook time should be greater than 60 seconds.
+        /// </summary>
+        [ViewVariables]
+        private uint _currentCookTimerTime = 1;
+
+        private bool Powered => !Owner.TryGetComponent(out PowerReceiverComponent? receiver) || receiver.Powered;
+        private bool _hasContents => Owner.TryGetComponent(out SolutionContainerComponent? solution) && (solution.ReagentList.Count > 0 || _storage.ContainedEntities.Count > 0);
+        private bool _uiDirty = true;
+        private bool _lostPower = false;
+        private int _currentCookTimeButtonIndex = 0;
+
+        void ISolutionChange.SolutionChanged(SolutionChangeEventArgs eventArgs) => _uiDirty = true;
+        private AudioSystem _audioSystem = default!;
+        private Container _storage = default!;
+
+        [ViewVariables] private BoundUserInterface? UserInterface => Owner.GetUIOrNull(MicrowaveUiKey.Key);
+
+        public override void Initialize()
+        {
+            base.Initialize();
+
+            _currentCookTimerTime = _cookTimeDefault;
+
+            Owner.EnsureComponent<SolutionContainerComponent>();
+
+            _storage = ContainerHelpers.EnsureContainer<Container>(Owner, "microwave_entity_container", out var existed);
+            _audioSystem = EntitySystem.Get<AudioSystem>();
+
+            if (UserInterface != null)
+            {
+                UserInterface.OnReceiveMessage += UserInterfaceOnReceiveMessage;
+            }
+        }
+
+        private void UserInterfaceOnReceiveMessage(ServerBoundUserInterfaceMessage message)
+        {
+            if (!Powered || _busy)
+            {
+                return;
+            }
+
+            switch (message.Message)
+            {
+                case MicrowaveStartCookMessage msg :
+                    Wzhzhzh();
+                    break;
+                case MicrowaveEjectMessage msg :
+                    if (_hasContents)
+                    {
+                        VaporizeReagents();
+                        EjectSolids();
+                        ClickSound();
+                        _uiDirty = true;
+                    }
+                    break;
+                case MicrowaveEjectSolidIndexedMessage msg:
+                    if (_hasContents)
+                    {
+                        EjectSolid(msg.EntityID);
+                        ClickSound();
+                        _uiDirty = true;
+                    }
+                    break;
+                case MicrowaveVaporizeReagentIndexedMessage msg:
+                    if (_hasContents)
+                    {
+                        VaporizeReagentQuantity(msg.ReagentQuantity);
+                        ClickSound();
+                        _uiDirty = true;
+                    }
+                    break;
+                case MicrowaveSelectCookTimeMessage msg:
+                    _currentCookTimeButtonIndex = msg.ButtonIndex;
+                    _currentCookTimerTime = msg.NewCookTime;
+                    ClickSound();
+                    _uiDirty = true;
+                    break;
+            }
+
+        }
+
+        public void OnUpdate()
+        {
+
+            if (!Powered)
+            {
+                //TODO:If someone cuts power currently, microwave magically keeps going. FIX IT!
+                SetAppearance(MicrowaveVisualState.Idle);
+            }
+
+            if (_busy && !Powered)
+            {
+                //we lost power while we were cooking/busy!
+                _lostPower = true;
+                VaporizeReagents();
+                EjectSolids();
+                _busy = false;
+                _uiDirty = true;
+            }
+
+            if (_uiDirty && Owner.TryGetComponent(out SolutionContainerComponent? solution))
+            {
+                UserInterface?.SetState(new MicrowaveUpdateUserInterfaceState
+                (
+                    solution.Solution.Contents.ToArray(),
+                    _storage.ContainedEntities.Select(item => item.Uid).ToArray(),
+                    _busy,
+                    _currentCookTimeButtonIndex,
+                    _currentCookTimerTime
+                ));
+                _uiDirty = false;
+            }
+        }
+
+        private void SetAppearance(MicrowaveVisualState state)
+        {
+            if (Owner.TryGetComponent(out AppearanceComponent? appearance))
+            {
+                appearance.SetData(PowerDeviceVisuals.VisualState, state);
+            }
+        }
+
+        void IActivate.Activate(ActivateEventArgs eventArgs)
+        {
+            if (!eventArgs.User.TryGetComponent(out ActorComponent? actor) || !Powered)
+            {
+                return;
+            }
+
+            _uiDirty = true;
+            UserInterface?.Toggle(actor.PlayerSession);
+        }
+
+        async Task<bool> IInteractUsing.InteractUsing(InteractUsingEventArgs eventArgs)
+        {
+            if (!Powered)
+            {
+                Owner.PopupMessage(eventArgs.User, Loc.GetString("It has no power!"));
+                return false;
+            }
+
+            var itemEntity = eventArgs.User.GetComponent<HandsComponent>().GetActiveHand?.Owner;
+
+            if (itemEntity == null)
+            {
+                eventArgs.User.PopupMessage(Loc.GetString("You have no active hand!"));
+                return false;
+            }
+
+            if (itemEntity.TryGetComponent<SolutionTransferComponent>(out var attackPourable))
+            {
+                if (!itemEntity.TryGetComponent<ISolutionInteractionsComponent>(out var attackSolution)
+                    || !attackSolution.CanDrain)
+                {
+                    return false;
+                }
+
+                if (!Owner.TryGetComponent(out SolutionContainerComponent? solution))
+                {
+                    return false;
+                }
+
+                //Get transfer amount. May be smaller than _transferAmount if not enough room
+                var realTransferAmount = ReagentUnit.Min(attackPourable.TransferAmount, solution.EmptyVolume);
+                if (realTransferAmount <= 0) //Special message if container is full
+                {
+                    Owner.PopupMessage(eventArgs.User, Loc.GetString("Container is full"));
+                    return false;
+                }
+
+                //Move units from attackSolution to targetSolution
+                var removedSolution = attackSolution.Drain(realTransferAmount);
+                if (!solution.TryAddSolution(removedSolution))
+                {
+                    return false;
+                }
+
+                Owner.PopupMessage(eventArgs.User, Loc.GetString("Transferred {0}u", removedSolution.TotalVolume));
+                return true;
+            }
+
+            if (!itemEntity.TryGetComponent(typeof(ItemComponent), out var food))
+            {
+
+                Owner.PopupMessage(eventArgs.User, "That won't work!");
+                return false;
+            }
+
+            var ent = food.Owner; //Get the entity of the ItemComponent.
+            _storage.Insert(ent);
+            _uiDirty = true;
+            return true;
+        }
+
+        // ReSharper disable once InconsistentNaming
+        // ReSharper disable once IdentifierTypo
+        private void Wzhzhzh()
+        {
+            if (!_hasContents)
+            {
+                return;
+            }
+
+            _busy = true;
+            // Convert storage into Dictionary of ingredients
+            var solidsDict = new Dictionary<string, int>();
+            foreach(var item in _storage.ContainedEntities)
+            {
+                if (item.Prototype == null)
+                {
+                    continue;
+                }
+
+                if(solidsDict.ContainsKey(item.Prototype.ID))
+                {
+                    solidsDict[item.Prototype.ID]++;
+                }
+                else
+                {
+                    solidsDict.Add(item.Prototype.ID, 1);
+                }
+            }
+
+            var failState = MicrowaveSuccessState.RecipeFail;
+            foreach(var id in solidsDict.Keys)
+            {
+                if(_recipeManager.SolidAppears(id))
+                {
+                    continue;
+                }
+
+                failState = MicrowaveSuccessState.UnwantedForeignObject;
+                break;
+            }
+
+            // Check recipes
+            FoodRecipePrototype? recipeToCook = null;
+            foreach (var r in _recipeManager.Recipes.Where(r => CanSatisfyRecipe(r, solidsDict) == MicrowaveSuccessState.RecipePass))
+            {
+                recipeToCook = r;
+            }
+
+            SetAppearance(MicrowaveVisualState.Cooking);
+            SoundSystem.Play(Filter.Pvs(Owner), _startCookingSound, Owner, AudioParams.Default);
+            Owner.SpawnTimer((int)(_currentCookTimerTime * _cookTimeMultiplier), (Action)(() =>
+            {
+                if (_lostPower)
+                {
+                    return;
+                }
+
+                if(failState == MicrowaveSuccessState.UnwantedForeignObject)
+                {
+                    VaporizeReagents();
+                    EjectSolids();
+                }
+                else
+                {
+                    if (recipeToCook != null)
+                    {
+                        SubtractContents(recipeToCook);
+                        Owner.EntityManager.SpawnEntity(recipeToCook.Result, Owner.Transform.Coordinates);
+                    }
+                    else
+                    {
+                        VaporizeReagents();
+                        VaporizeSolids();
+                        Owner.EntityManager.SpawnEntity(_badRecipeName, Owner.Transform.Coordinates);
+                    }
+                }
+                SoundSystem.Play(Filter.Pvs(Owner), _cookingCompleteSound, Owner, AudioParams.Default.WithVolume(-1f));
+
+                SetAppearance(MicrowaveVisualState.Idle);
+                _busy = false;
+
+                _uiDirty = true;
+            }));
+            _lostPower = false;
+            _uiDirty = true;
+        }
+
+        private void VaporizeReagents()
+        {
+            if (Owner.TryGetComponent(out SolutionContainerComponent? solution))
+            {
+                solution.RemoveAllSolution();
+            }
+        }
+
+        private void VaporizeReagentQuantity(Solution.ReagentQuantity reagentQuantity)
+        {
+            if (Owner.TryGetComponent(out SolutionContainerComponent? solution))
+            {
+                solution?.TryRemoveReagent(reagentQuantity.ReagentId, reagentQuantity.Quantity);
+            }
+        }
+
+        private void VaporizeSolids()
+        {
+            for(var i = _storage.ContainedEntities.Count-1; i>=0; i--)
+            {
+                var item = _storage.ContainedEntities.ElementAt(i);
+                _storage.Remove(item);
+                item.Delete();
+            }
+        }
+
+        private void EjectSolids()
+        {
+
+            for(var i = _storage.ContainedEntities.Count-1; i>=0; i--)
+            {
+                _storage.Remove(_storage.ContainedEntities.ElementAt(i));
+            }
+        }
+
+        private void EjectSolid(EntityUid entityID)
+        {
+            if (Owner.EntityManager.EntityExists(entityID))
+            {
+                _storage.Remove(Owner.EntityManager.GetEntity(entityID));
+            }
+        }
+
+
+        private void SubtractContents(FoodRecipePrototype recipe)
+        {
+            if (!Owner.TryGetComponent(out SolutionContainerComponent? solution))
+            {
+                return;
+            }
+
+            foreach(var recipeReagent in recipe.IngredientsReagents)
+            {
+                solution?.TryRemoveReagent(recipeReagent.Key, ReagentUnit.New(recipeReagent.Value));
+            }
+
+            foreach (var recipeSolid in recipe.IngredientsSolids)
+            {
+                for (var i = 0; i < recipeSolid.Value; i++)
+                {
+                    foreach (var item in _storage.ContainedEntities)
+                    {
+                        if (item.Prototype == null)
+                        {
+                            continue;
+                        }
+
+                        if (item.Prototype.ID == recipeSolid.Key)
+                        {
+                            _storage.Remove(item);
+                            item.Delete();
+                            break;
+                        }
+                    }
+                }
+            }
+
+        }
+
+        private MicrowaveSuccessState CanSatisfyRecipe(FoodRecipePrototype recipe, Dictionary<string,int> solids)
+        {
+            if (_currentCookTimerTime != (uint) recipe.CookTime)
+            {
+                return MicrowaveSuccessState.RecipeFail;
+            }
+
+            if (!Owner.TryGetComponent(out SolutionContainerComponent? solution))
+            {
+                return MicrowaveSuccessState.RecipeFail;
+            }
+
+            foreach (var reagent in recipe.IngredientsReagents)
+            {
+                if (!solution.Solution.ContainsReagent(reagent.Key, out var amount))
+                {
+                    return MicrowaveSuccessState.RecipeFail;
+                }
+
+                if (amount.Int() < reagent.Value)
+                {
+                    return MicrowaveSuccessState.RecipeFail;
+                }
+            }
+
+            foreach (var solid in recipe.IngredientsSolids)
+            {
+                if (!solids.ContainsKey(solid.Key))
+                {
+                    return MicrowaveSuccessState.RecipeFail;
+                }
+
+                if (solids[solid.Key] < solid.Value)
+                {
+                    return MicrowaveSuccessState.RecipeFail;
+                }
+            }
+
+            return MicrowaveSuccessState.RecipePass;
+        }
+
+        private void ClickSound()
+        {
+            SoundSystem.Play(Filter.Pvs(Owner), "/Audio/Machines/machine_switch.ogg",Owner,AudioParams.Default.WithVolume(-2f));
+        }
+
+        SuicideKind ISuicideAct.Suicide(IEntity victim, IChatManager chat)
+        {
+            var headCount = 0;
+
+            if (victim.TryGetComponent<IBody>(out var body))
+            {
+                var headSlots = body.GetSlotsOfType(BodyPartType.Head);
+
+                foreach (var slot in headSlots)
+                {
+                    var part = slot.Part;
+
+                    if (part == null ||
+                        !body.TryDropPart(slot, out var dropped))
+                    {
+                        continue;
+                    }
+
+                    foreach (var droppedPart in dropped.Values)
+                    {
+                        if (droppedPart.PartType != BodyPartType.Head)
+                        {
+                            continue;
+                        }
+
+                        _storage.Insert(droppedPart.Owner);
+                        headCount++;
+                    }
+                }
+            }
+
+            var othersMessage = headCount > 1
+                ? Loc.GetString("{0:theName} is trying to cook {0:their} heads!", victim)
+                : Loc.GetString("{0:theName} is trying to cook {0:their} head!", victim);
+
+            victim.PopupMessageOtherClients(othersMessage);
+
+            var selfMessage = headCount > 1
+                ? Loc.GetString("You cook your heads!")
+                : Loc.GetString("You cook your head!");
+
+            victim.PopupMessage(selfMessage);
+
+            _currentCookTimerTime = 10;
+            ClickSound();
+            _uiDirty = true;
+            Wzhzhzh();
+            return SuicideKind.Heat;
+        }
+    }
+}

Content.Server/Kitchen/Components/MicrowaveSuccessState.cs

@@ -0,0 +1,10 @@
+namespace Content.Server.Kitchen.Components
+{
+    public enum MicrowaveSuccessState
+    {
+        RecipePass,
+        RecipeFail,
+        UnwantedForeignObject
+
+    }
+}

Content.Server/Kitchen/Components/ReagentGrinderComponent.cs

@@ -0,0 +1,368 @@
+#nullable enable
+using System;
+using System.Linq;
+using System.Threading.Tasks;
+using Content.Server.Chemistry.Components;
+using Content.Server.Hands.Components;
+using Content.Server.Items;
+using Content.Server.Power.Components;
+using Content.Server.UserInterface;
+using Content.Shared.Chemistry.Solution;
+using Content.Shared.Interaction;
+using Content.Shared.Kitchen.Components;
+using Content.Shared.Notification;
+using Content.Shared.Random.Helpers;
+using Content.Shared.Tag;
+using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.Containers;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Localization;
+using Robust.Shared.Player;
+using Robust.Shared.Serialization.Manager.Attributes;
+using Robust.Shared.ViewVariables;
+
+namespace Content.Server.Kitchen.Components
+{
+
+    /// <summary>
+    /// The combo reagent grinder/juicer. The reason why grinding and juicing are seperate is simple,
+    /// think of grinding as a utility to break an object down into its reagents. Think of juicing as
+    /// converting something into its single juice form. E.g, grind an apple and get the nutriment and sugar
+    /// it contained, juice an apple and get "apple juice".
+    /// </summary>
+    [RegisterComponent]
+    [ComponentReference(typeof(IActivate))]
+    public class ReagentGrinderComponent : SharedReagentGrinderComponent, IActivate, IInteractUsing
+    {
+        private AudioSystem _audioSystem = default!;
+        [ViewVariables] private ContainerSlot _beakerContainer = default!;
+
+        /// <summary>
+        /// Can be null since we won't always have a beaker in the grinder.
+        /// </summary>
+        [ViewVariables] private SolutionContainerComponent? _heldBeaker = default!;
+
+        /// <summary>
+        /// Contains the things that are going to be ground or juiced.
+        /// </summary>
+        [ViewVariables] private Container _chamber = default!;
+
+        [ViewVariables] private bool ChamberEmpty => _chamber.ContainedEntities.Count <= 0;
+        [ViewVariables] private bool HasBeaker => _beakerContainer.ContainedEntity != null;
+        [ViewVariables] private BoundUserInterface? UserInterface => Owner.GetUIOrNull(ReagentGrinderUiKey.Key);
+
+        private bool Powered => !Owner.TryGetComponent(out PowerReceiverComponent? receiver) || receiver.Powered;
+
+        /// <summary>
+        /// Should the BoundUI be told to update?
+        /// </summary>
+        private bool _uiDirty = true;
+        /// <summary>
+        /// Is the machine actively doing something and can't be used right now?
+        /// </summary>
+        private bool _busy = false;
+
+        //YAML serialization vars
+        [ViewVariables(VVAccess.ReadWrite)] [DataField("chamberCapacity")] private int _storageCap = 16;
+        [ViewVariables(VVAccess.ReadWrite)] [DataField("workTime")] private int _workTime = 3500; //3.5 seconds, completely arbitrary for now.
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            //A slot for the beaker where the grounds/juices will go.
+            _beakerContainer =
+                ContainerHelpers.EnsureContainer<ContainerSlot>(Owner, $"{Name}-reagentContainerContainer");
+
+            //A container for the things that WILL be ground/juiced. Useful for ejecting them instead of deleting them from the hands of the user.
+            _chamber =
+                ContainerHelpers.EnsureContainer<Container>(Owner, $"{Name}-entityContainerContainer");
+
+            if (UserInterface != null)
+            {
+                UserInterface.OnReceiveMessage += UserInterfaceOnReceiveMessage;
+            }
+
+            _audioSystem = EntitySystem.Get<AudioSystem>();
+        }
+
+        public override void HandleMessage(ComponentMessage message, IComponent? component)
+        {
+            base.HandleMessage(message, component);
+            switch (message)
+            {
+                case PowerChangedMessage powerChanged:
+                    OnPowerStateChanged(powerChanged);
+                    break;
+            }
+        }
+
+        public override void OnRemove()
+        {
+            base.OnRemove();
+            if (UserInterface != null)
+            {
+                UserInterface.OnReceiveMessage -= UserInterfaceOnReceiveMessage;
+            }
+        }
+
+        private void UserInterfaceOnReceiveMessage(ServerBoundUserInterfaceMessage message)
+        {
+            if(_busy)
+            {
+                return;
+            }
+
+            switch(message.Message)
+            {
+                case ReagentGrinderGrindStartMessage msg:
+                    if (!Powered) break;
+                    ClickSound();
+                    DoWork(message.Session.AttachedEntity!, GrinderProgram.Grind);
+                    break;
+
+                case ReagentGrinderJuiceStartMessage msg:
+                    if (!Powered) break;
+                    ClickSound();
+                    DoWork(message.Session.AttachedEntity!, GrinderProgram.Juice);
+                    break;
+
+                case ReagentGrinderEjectChamberAllMessage msg:
+                    if(!ChamberEmpty)
+                    {
+                        ClickSound();
+                        for (var i = _chamber.ContainedEntities.Count - 1; i >= 0; i--)
+                        {
+                            EjectSolid(_chamber.ContainedEntities.ElementAt(i).Uid);
+                        }
+                    }
+                    break;
+
+                case ReagentGrinderEjectChamberContentMessage msg:
+                    if (!ChamberEmpty)
+                    {
+                        EjectSolid(msg.EntityID);
+                        ClickSound();
+                        _uiDirty = true;
+                    }
+                    break;
+
+                case ReagentGrinderEjectBeakerMessage msg:
+                    ClickSound();
+                    EjectBeaker(message.Session.AttachedEntity);
+                    //EjectBeaker will dirty the UI for us, we don't have to do it explicitly here.
+                    break;
+            }
+        }
+
+        private void OnPowerStateChanged(PowerChangedMessage e)
+        {
+            _uiDirty = true;
+        }
+
+        private void ClickSound()
+        {
+            SoundSystem.Play(Filter.Pvs(Owner), "/Audio/Machines/machine_switch.ogg", Owner, AudioParams.Default.WithVolume(-2f));
+        }
+
+        private void SetAppearance()
+        {
+            if (Owner.TryGetComponent(out AppearanceComponent? appearance))
+            {
+                appearance.SetData(ReagentGrinderVisualState.BeakerAttached, HasBeaker);
+            }
+        }
+
+        public void OnUpdate()
+        {
+            if(_uiDirty)
+            {
+                UpdateInterface();
+                _uiDirty = false;
+            }
+        }
+
+        // This doesn't check for UI dirtiness so handle that when calling this.
+        private void UpdateInterface()
+        {
+            bool canJuice = false;
+            bool canGrind = false;
+            if (HasBeaker)
+            {
+                foreach (var entity in _chamber.ContainedEntities)
+                {
+                    if (!canJuice && entity.HasComponent<JuiceableComponent>()) canJuice = true;
+                    if (!canGrind && entity.HasTag("Grindable")) canGrind = true;
+                    if (canJuice && canGrind) break;
+                }
+            }
+
+            UserInterface?.SetState(new ReagentGrinderInterfaceState
+            (
+                _busy,
+                HasBeaker,
+                Powered,
+                canJuice,
+                canGrind,
+                _chamber.ContainedEntities.Select(item => item.Uid).ToArray(),
+                //Remember the beaker can be null!
+                _heldBeaker?.Solution.Contents.ToArray()
+            ));
+            _uiDirty = false;
+        }
+
+        private void EjectSolid(EntityUid entityID)
+        {
+            if (_busy)
+                return;
+
+            if (Owner.EntityManager.TryGetEntity(entityID, out var entity))
+            {
+                _chamber.Remove(entity);
+
+                //Give the ejected entity a tiny bit of offset so each one is apparent in case of a big stack,
+                //but (hopefully) not enough to clip it through a solid (wall).
+                entity.RandomOffset(0.4f);
+            }
+            _uiDirty = true;
+        }
+
+        /// <summary>
+        /// Tries to eject whatever is in the beaker slot. Puts the item in the user's hands or failing that on top
+        /// of the grinder.
+        /// </summary>
+        private void EjectBeaker(IEntity? user)
+        {
+            if (!HasBeaker || _heldBeaker == null || _busy)
+                return;
+
+            var beaker = _beakerContainer.ContainedEntity;
+            if(beaker is null)
+                return;
+
+            _beakerContainer.Remove(beaker);
+
+            if (user == null || !user.TryGetComponent<HandsComponent>(out var hands) || !_heldBeaker.Owner.TryGetComponent<ItemComponent>(out var item))
+                return;
+            hands.PutInHandOrDrop(item);
+
+            _heldBeaker = null;
+            _uiDirty = true;
+            SetAppearance();
+        }
+
+        void IActivate.Activate(ActivateEventArgs eventArgs)
+        {
+            if (!eventArgs.User.TryGetComponent(out ActorComponent? actor))
+            {
+                return;
+            }
+            _uiDirty = true;
+            UserInterface?.Toggle(actor.PlayerSession);
+        }
+
+        async Task<bool> IInteractUsing.InteractUsing(InteractUsingEventArgs eventArgs)
+        {
+            if (!eventArgs.User.TryGetComponent(out IHandsComponent? hands))
+            {
+                Owner.PopupMessage(eventArgs.User, Loc.GetString("You have no hands."));
+                return true;
+            }
+
+            IEntity heldEnt = eventArgs.Using;
+
+            //First, check if user is trying to insert a beaker.
+            //No promise it will be a beaker right now, but whatever.
+            //Maybe this should whitelist "beaker" in the prototype id of heldEnt?
+            if(heldEnt.TryGetComponent(out SolutionContainerComponent? beaker) && beaker.Capabilities.HasFlag(SolutionContainerCaps.FitsInDispenser))
+            {
+                _beakerContainer.Insert(heldEnt);
+                _heldBeaker = beaker;
+                _uiDirty = true;
+                //We are done, return. Insert the beaker and exit!
+                SetAppearance();
+                ClickSound();
+                return true;
+            }
+
+            //Next, see if the user is trying to insert something they want to be ground/juiced.
+            if(!heldEnt.HasTag("Grindable") && !heldEnt.TryGetComponent(out JuiceableComponent? juice))
+            {
+                //Entity did NOT pass the whitelist for grind/juice.
+                //Wouldn't want the clown grinding up the Captain's ID card now would you?
+                //Why am I asking you? You're biased.
+                return false;
+            }
+
+            //Cap the chamber. Don't want someone putting in 500 entities and ejecting them all at once.
+            //Maybe I should have done that for the microwave too?
+            if (_chamber.ContainedEntities.Count >= _storageCap)
+            {
+                return false;
+            }
+
+            if (!_chamber.Insert(heldEnt))
+                return false;
+
+            _uiDirty = true;
+            return true;
+        }
+
+        /// <summary>
+        /// The wzhzhzh of the grinder. Processes the contents of the grinder and puts the output in the beaker.
+        /// </summary>
+        /// <param name="isJuiceIntent">true for wanting to juice, false for wanting to grind.</param>
+        private async void DoWork(IEntity user, GrinderProgram program)
+        {
+            //Have power, are  we busy, chamber has anything to grind, a beaker for the grounds to go?
+            if(!Powered || _busy || ChamberEmpty || !HasBeaker || _heldBeaker == null)
+            {
+                return;
+            }
+
+            _busy = true;
+
+            UserInterface?.SendMessage(new ReagentGrinderWorkStartedMessage(program));
+            switch (program)
+            {
+                case GrinderProgram.Grind:
+                    SoundSystem.Play(Filter.Pvs(Owner), "/Audio/Machines/blender.ogg", Owner, AudioParams.Default);
+                    //Get each item inside the chamber and get the reagents it contains. Transfer those reagents to the beaker, given we have one in.
+                    Owner.SpawnTimer(_workTime, (Action) (() =>
+                    {
+                        foreach (var item in _chamber.ContainedEntities.ToList())
+                        {
+                            if (!item.HasTag("Grindable")) continue;
+                            if (!item.TryGetComponent<SolutionContainerComponent>(out var solution)) continue;
+                            if (_heldBeaker.CurrentVolume + solution.CurrentVolume > _heldBeaker.MaxVolume) continue;
+                            _heldBeaker.TryAddSolution(solution.Solution);
+                            solution.RemoveAllSolution();
+                            item.Delete();
+                        }
+
+                        _busy = false;
+                        _uiDirty = true;
+                        UserInterface?.SendMessage(new ReagentGrinderWorkCompleteMessage());
+                    }));
+                    break;
+
+                case GrinderProgram.Juice:
+                    SoundSystem.Play(Filter.Pvs(Owner), "/Audio/Machines/juicer.ogg", Owner, AudioParams.Default);
+                    Owner.SpawnTimer(_workTime, (Action) (() =>
+                    {
+                        foreach (var item in _chamber.ContainedEntities.ToList())
+                        {
+                            if (!item.TryGetComponent<JuiceableComponent>(out var juiceMe)) continue;
+                            if (_heldBeaker.CurrentVolume + juiceMe.JuiceResultSolution.TotalVolume > _heldBeaker.MaxVolume) continue;
+                            _heldBeaker.TryAddSolution(juiceMe.JuiceResultSolution);
+                            item.Delete();
+                        }
+                        UserInterface?.SendMessage(new ReagentGrinderWorkCompleteMessage());
+                        _busy = false;
+                        _uiDirty = true;
+                    }));
+                    break;
+            }
+        }
+    }
+}