Re-organize all projects (#4166)

Content.Server/Cargo/CargoConsoleSystem.cs

@@ -0,0 +1,208 @@
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using Content.Server.Cargo.Components;
+using Content.Shared.Cargo;
+using Content.Shared.GameTicking;
+using Robust.Shared.GameObjects;
+
+namespace Content.Server.Cargo
+{
+    public class CargoConsoleSystem : EntitySystem, IResettingEntitySystem
+    {
+        /// <summary>
+        /// How much time to wait (in seconds) before increasing bank accounts balance.
+        /// </summary>
+        private const float Delay = 10f;
+        /// <summary>
+        /// How many points to give to every bank account every <see cref="Delay"/> seconds.
+        /// </summary>
+        private const int PointIncrease = 150;
+
+        /// <summary>
+        /// Keeps track of how much time has elapsed since last balance increase.
+        /// </summary>
+        private float _timer;
+        /// <summary>
+        /// Stores all bank accounts.
+        /// </summary>
+        private readonly Dictionary<int, CargoBankAccount> _accountsDict = new();
+
+        private readonly Dictionary<int, CargoOrderDatabase> _databasesDict = new();
+        /// <summary>
+        /// Used to assign IDs to bank accounts. Incremental counter.
+        /// </summary>
+        private int _accountIndex = 0;
+        /// <summary>
+        /// Enumeration of all bank accounts.
+        /// </summary>
+        public IEnumerable<CargoBankAccount> BankAccounts => _accountsDict.Values;
+        /// <summary>
+        /// The station's bank account.
+        /// </summary>
+        public CargoBankAccount StationAccount => GetBankAccount(0);
+
+        public CargoOrderDatabase StationOrderDatabase => GetOrderDatabase(0);
+
+        public override void Initialize()
+        {
+            CreateBankAccount("Space Station 14", 1000);
+            CreateOrderDatabase(0);
+        }
+
+        public override void Update(float frameTime)
+        {
+            _timer += frameTime;
+            if (_timer < Delay)
+            {
+                return;
+            }
+
+            _timer -= Delay;
+            foreach (var account in BankAccounts)
+            {
+                account.Balance += PointIncrease;
+            }
+        }
+
+        public void Reset()
+        {
+            _accountsDict.Clear();
+            _databasesDict.Clear();
+            _timer = 0;
+            _accountIndex = 0;
+            Initialize();
+        }
+
+        /// <summary>
+        /// Creates a new bank account.
+        /// </summary>
+        public void CreateBankAccount(string name, int balance)
+        {
+            var account = new CargoBankAccount(_accountIndex, name, balance);
+            _accountsDict.Add(_accountIndex, account);
+            _accountIndex += 1;
+        }
+
+        public void CreateOrderDatabase(int id)
+        {
+            _databasesDict.Add(id, new CargoOrderDatabase(id));
+        }
+
+        /// <summary>
+        /// Returns the bank account associated with the given ID.
+        /// </summary>
+        public CargoBankAccount GetBankAccount(int id)
+        {
+            return _accountsDict[id];
+        }
+
+        public CargoOrderDatabase GetOrderDatabase(int id)
+        {
+            return _databasesDict[id];
+        }
+
+        /// <summary>
+        /// Returns whether the account exists, eventually passing the account in the out parameter.
+        /// </summary>
+        public bool TryGetBankAccount(int id, [NotNullWhen(true)] out CargoBankAccount? account)
+        {
+            return _accountsDict.TryGetValue(id, out account);
+        }
+
+        public bool TryGetOrderDatabase(int id, [NotNullWhen(true)] out CargoOrderDatabase? database)
+        {
+            return _databasesDict.TryGetValue(id, out database);
+        }
+        /// <summary>
+        /// Verifies if there is enough money in the account's balance to pay the amount.
+        /// Returns false if there's no account associated with the given ID
+        /// or if the balance would end up being negative.
+        /// </summary>
+        public bool CheckBalance(int id, int amount)
+        {
+            if (!TryGetBankAccount(id, out var account))
+            {
+                return false;
+            }
+
+            if (account.Balance + amount < 0)
+            {
+                return false;
+            }
+
+            return true;
+        }
+        /// <summary>
+        /// Attempts to change the given account's balance.
+        /// Returns false if there's no account associated with the given ID
+        /// or if the balance would end up being negative.
+        /// </summary>
+        public bool ChangeBalance(int id, int amount)
+        {
+            if (!TryGetBankAccount(id, out var account))
+            {
+                return false;
+            }
+
+            account.Balance += amount;
+            return true;
+        }
+
+        public bool AddOrder(int id, string requester, string reason, string productId, int amount, int payingAccountId)
+        {
+            if (amount < 1 || !TryGetOrderDatabase(id, out var database) || amount > database.MaxOrderSize)
+            {
+                return false;
+            }
+
+            database.AddOrder(requester, reason, productId, amount, payingAccountId);
+            SyncComponentsWithId(id);
+            return true;
+        }
+
+        public bool RemoveOrder(int id, int orderNumber)
+        {
+            if (!TryGetOrderDatabase(id, out var database))
+                return false;
+            database.RemoveOrder(orderNumber);
+            SyncComponentsWithId(id);
+            return true;
+        }
+
+        public bool ApproveOrder(int id, int orderNumber)
+        {
+            if (!TryGetOrderDatabase(id, out var database))
+                return false;
+            if (!database.ApproveOrder(orderNumber))
+                return false;
+            SyncComponentsWithId(id);
+            return true;
+        }
+
+        public List<CargoOrderData> RemoveAndGetApprovedOrders(int id)
+        {
+            if (!TryGetOrderDatabase(id, out var database))
+                return new List<CargoOrderData>();
+            var approvedOrders = database.SpliceApproved();
+            SyncComponentsWithId(id);
+            return approvedOrders;
+        }
+
+        public (int CurrentCapacity, int MaxCapacity) GetCapacity(int id)
+        {
+            if (!TryGetOrderDatabase(id, out var database))
+                return (0,0);
+            return (database.CurrentOrderSize, database.MaxOrderSize);
+        }
+
+        private void SyncComponentsWithId(int id)
+        {
+            foreach (var comp in ComponentManager.EntityQuery<CargoOrderDatabaseComponent>(true))
+            {
+                if (comp.Database == null || comp.Database.Id != id)
+                    continue;
+                comp.Dirty();
+            }
+        }
+    }
+}

Content.Server/Cargo/CargoOrderDatabase.cs

@@ -1,7 +1,7 @@
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
-using Content.Shared.Prototypes.Cargo;
+using Content.Shared.Cargo;
 using Robust.Shared.Localization;
 
 namespace Content.Server.Cargo

Content.Server/Cargo/Components/CargoConsoleComponent.cs

@@ -0,0 +1,229 @@
+#nullable enable
+using System.Collections.Generic;
+using Content.Server.Coordinates.Helpers;
+using Content.Server.Power.Components;
+using Content.Server.UserInterface;
+using Content.Shared.Cargo;
+using Content.Shared.Cargo.Components;
+using Content.Shared.Interaction;
+using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Map;
+using Robust.Shared.Maths;
+using Robust.Shared.Player;
+using Robust.Shared.Serialization.Manager.Attributes;
+using Robust.Shared.ViewVariables;
+
+namespace Content.Server.Cargo.Components
+{
+    [RegisterComponent]
+    [ComponentReference(typeof(IActivate))]
+    public class CargoConsoleComponent : SharedCargoConsoleComponent, IActivate
+    {
+        [Dependency] private readonly IMapManager _mapManager = default!;
+
+        [ViewVariables]
+        public int Points = 1000;
+
+        private CargoBankAccount? _bankAccount;
+
+        [ViewVariables]
+        public CargoBankAccount? BankAccount
+        {
+            get => _bankAccount;
+            private set
+            {
+                if (_bankAccount == value)
+                {
+                    return;
+                }
+
+                if (_bankAccount != null)
+                {
+                    _bankAccount.OnBalanceChange -= UpdateUIState;
+                }
+
+                _bankAccount = value;
+
+                if (value != null)
+                {
+                    value.OnBalanceChange += UpdateUIState;
+                }
+
+                UpdateUIState();
+            }
+        }
+
+        [DataField("requestOnly")]
+        private bool _requestOnly = false;
+
+        private bool Powered => !Owner.TryGetComponent(out PowerReceiverComponent? receiver) || receiver.Powered;
+        private CargoConsoleSystem _cargoConsoleSystem = default!;
+
+        [ViewVariables] private BoundUserInterface? UserInterface => Owner.GetUIOrNull(CargoConsoleUiKey.Key);
+
+        public override void Initialize()
+        {
+            base.Initialize();
+
+            Owner.EnsureComponentWarn(out GalacticMarketComponent _);
+            Owner.EnsureComponentWarn(out CargoOrderDatabaseComponent _);
+
+            if (UserInterface != null)
+            {
+                UserInterface.OnReceiveMessage += UserInterfaceOnOnReceiveMessage;
+            }
+
+            _cargoConsoleSystem = EntitySystem.Get<CargoConsoleSystem>();
+            BankAccount = _cargoConsoleSystem.StationAccount;
+        }
+
+        public override void OnRemove()
+        {
+            if (UserInterface != null)
+            {
+                UserInterface.OnReceiveMessage -= UserInterfaceOnOnReceiveMessage;
+            }
+
+            base.OnRemove();
+        }
+
+        private void UserInterfaceOnOnReceiveMessage(ServerBoundUserInterfaceMessage serverMsg)
+        {
+            if (!Owner.TryGetComponent(out CargoOrderDatabaseComponent? orders))
+            {
+                return;
+            }
+
+            var message = serverMsg.Message;
+            if (orders.Database == null)
+                return;
+            if (!Powered)
+                return;
+            switch (message)
+            {
+                case CargoConsoleAddOrderMessage msg:
+                {
+                    if (msg.Amount <= 0 || _bankAccount == null)
+                    {
+                        break;
+                    }
+
+                    if (!_cargoConsoleSystem.AddOrder(orders.Database.Id, msg.Requester, msg.Reason, msg.ProductId,
+                        msg.Amount, _bankAccount.Id))
+                    {
+                        SoundSystem.Play(Filter.Local(), "/Audio/Effects/error.ogg", Owner, AudioParams.Default);
+                    }
+                    break;
+                }
+                case CargoConsoleRemoveOrderMessage msg:
+                {
+                    _cargoConsoleSystem.RemoveOrder(orders.Database.Id, msg.OrderNumber);
+                    break;
+                }
+                case CargoConsoleApproveOrderMessage msg:
+                {
+                    if (_requestOnly ||
+                        !orders.Database.TryGetOrder(msg.OrderNumber, out var order) ||
+                        _bankAccount == null)
+                    {
+                        break;
+                    }
+
+                    PrototypeManager.TryIndex(order.ProductId, out CargoProductPrototype? product);
+                    if (product == null!)
+                        break;
+                    var capacity = _cargoConsoleSystem.GetCapacity(orders.Database.Id);
+                    if (
+                        capacity.CurrentCapacity == capacity.MaxCapacity
+                        || capacity.CurrentCapacity + order.Amount > capacity.MaxCapacity
+                        || !_cargoConsoleSystem.CheckBalance(_bankAccount.Id, (-product.PointCost) * order.Amount)
+                        || !_cargoConsoleSystem.ApproveOrder(orders.Database.Id, msg.OrderNumber)
+                        || !_cargoConsoleSystem.ChangeBalance(_bankAccount.Id, (-product.PointCost) * order.Amount)
+                        )
+                    {
+                        SoundSystem.Play(Filter.Local(), "/Audio/Effects/error.ogg", Owner, AudioParams.Default);
+                        break;
+                    }
+                    UpdateUIState();
+                    break;
+                }
+                case CargoConsoleShuttleMessage _:
+                {
+                    //var approvedOrders = _cargoOrderDataManager.RemoveAndGetApprovedFrom(orders.Database);
+                    //orders.Database.ClearOrderCapacity();
+
+                    // TODO replace with shuttle code
+                    // TEMPORARY loop for spawning stuff on telepad (looks for a telepad adjacent to the console)
+                    IEntity? cargoTelepad = null;
+                    var indices = Owner.Transform.Coordinates.ToVector2i(Owner.EntityManager, _mapManager);
+                    var offsets = new Vector2i[] { new Vector2i(0, 1), new Vector2i(1, 1), new Vector2i(1, 0), new Vector2i(1, -1),
+                                                   new Vector2i(0, -1), new Vector2i(-1, -1), new Vector2i(-1, 0), new Vector2i(-1, 1), };
+                    var adjacentEntities = new List<IEnumerable<IEntity>>(); //Probably better than IEnumerable.concat
+                    foreach (var offset in offsets)
+                    {
+                        adjacentEntities.Add((indices+offset).GetEntitiesInTileFast(Owner.Transform.GridID));
+                    }
+
+                    foreach (var enumerator in adjacentEntities)
+                    {
+                        foreach (IEntity entity in enumerator)
+                        {
+                            if (entity.HasComponent<CargoTelepadComponent>() && entity.TryGetComponent<PowerReceiverComponent>(out var powerReceiver) && powerReceiver.Powered)
+                            {
+                                cargoTelepad = entity;
+                                break;
+                            }
+                        }
+                    }
+                    if (cargoTelepad != null)
+                    {
+                        if (cargoTelepad.TryGetComponent<CargoTelepadComponent>(out var telepadComponent))
+                        {
+                            var approvedOrders = _cargoConsoleSystem.RemoveAndGetApprovedOrders(orders.Database.Id);
+                            orders.Database.ClearOrderCapacity();
+                            foreach (var order in approvedOrders)
+                            {
+                                if (!PrototypeManager.TryIndex(order.ProductId, out CargoProductPrototype? product))
+                                    continue;
+                                for (var i = 0; i < order.Amount; i++)
+                                {
+                                    telepadComponent.QueueTeleport(product);
+                                }
+                            }
+                        }
+                    }
+                    break;
+                }
+            }
+        }
+
+        void IActivate.Activate(ActivateEventArgs eventArgs)
+        {
+            if (!eventArgs.User.TryGetComponent(out ActorComponent? actor))
+            {
+                return;
+            }
+            if (!Powered)
+                return;
+
+            UserInterface?.Open(actor.PlayerSession);
+        }
+
+        private void UpdateUIState()
+        {
+            if (_bankAccount == null || !Owner.IsValid())
+            {
+                return;
+            }
+
+            var id = _bankAccount.Id;
+            var name = _bankAccount.Name;
+            var balance = _bankAccount.Balance;
+            var capacity = _cargoConsoleSystem.GetCapacity(id);
+            UserInterface?.SetState(new CargoConsoleInterfaceState(_requestOnly, id, name, balance, capacity));
+        }
+    }
+}

Content.Server/Cargo/Components/CargoOrderDatabaseComponent.cs

@@ -0,0 +1,27 @@
+using Content.Shared.Cargo.Components;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Players;
+
+namespace Content.Server.Cargo.Components
+{
+    [RegisterComponent]
+    public class CargoOrderDatabaseComponent : SharedCargoOrderDatabaseComponent
+    {
+        public CargoOrderDatabase? Database { get; set; }
+        public bool ConnectedToDatabase => Database != null;
+
+        public override void Initialize()
+        {
+            base.Initialize();
+
+            Database = EntitySystem.Get<CargoConsoleSystem>().StationOrderDatabase;
+        }
+
+        public override ComponentState GetComponentState(ICommonSession player)
+        {
+            if (!ConnectedToDatabase)
+                return new CargoOrderDatabaseState(null);
+            return new CargoOrderDatabaseState(Database?.GetOrders());
+        }
+    }
+}

Content.Server/Cargo/Components/CargoTelepadComponent.cs

@@ -0,0 +1,91 @@
+#nullable enable
+using System.Collections.Generic;
+using Content.Server.Power.Components;
+using Content.Shared.Cargo;
+using Robust.Server.GameObjects;
+using Robust.Shared.Audio;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Player;
+
+namespace Content.Server.Cargo.Components
+{
+
+    //This entire class is a PLACEHOLDER for the cargo shuttle.
+
+    [RegisterComponent]
+    public class CargoTelepadComponent : Component
+    {
+        public override string Name => "CargoTelepad";
+
+        private const float TeleportDuration = 0.5f;
+        private const float TeleportDelay = 15f;
+        private List<CargoProductPrototype> _teleportQueue = new List<CargoProductPrototype>();
+        private CargoTelepadState _currentState = CargoTelepadState.Unpowered;
+
+        public override void HandleMessage(ComponentMessage message, IComponent? component)
+        {
+            base.HandleMessage(message, component);
+            switch (message)
+            {
+                case PowerChangedMessage powerChanged:
+                    PowerUpdate(powerChanged);
+                    break;
+            }
+        }
+
+        public void QueueTeleport(CargoProductPrototype product)
+        {
+            _teleportQueue.Add(product);
+            TeleportLoop();
+        }
+
+        private void PowerUpdate(PowerChangedMessage args)
+        {
+            if (args.Powered && _currentState == CargoTelepadState.Unpowered) {
+                _currentState = CargoTelepadState.Idle;
+                if(Owner.TryGetComponent<SpriteComponent>(out var spriteComponent))
+                    spriteComponent.LayerSetState(0, "idle");
+                TeleportLoop();
+            }
+            else if (!args.Powered)
+            {
+                _currentState = CargoTelepadState.Unpowered;
+                if (Owner.TryGetComponent<SpriteComponent>(out var spriteComponent))
+                    spriteComponent.LayerSetState(0, "offline");
+            }
+        }
+        private void TeleportLoop()
+        {
+            if (_currentState == CargoTelepadState.Idle && _teleportQueue.Count > 0)
+            {
+                _currentState = CargoTelepadState.Charging;
+                if (Owner.TryGetComponent<SpriteComponent>(out var spriteComponent))
+                    spriteComponent.LayerSetState(0, "idle");
+                Owner.SpawnTimer((int) (TeleportDelay * 1000), () =>
+                {
+                    if (!Deleted && !Owner.Deleted && _currentState == CargoTelepadState.Charging && _teleportQueue.Count > 0)
+                    {
+                        _currentState = CargoTelepadState.Teleporting;
+                        if (Owner.TryGetComponent<SpriteComponent>(out var spriteComponent))
+                            spriteComponent.LayerSetState(0, "beam");
+                        Owner.SpawnTimer((int) (TeleportDuration * 1000), () =>
+                        {
+                            if (!Deleted && !Owner.Deleted && _currentState == CargoTelepadState.Teleporting && _teleportQueue.Count > 0)
+                            {
+                                SoundSystem.Play(Filter.Pvs(Owner), "/Audio/Machines/phasein.ogg", Owner, AudioParams.Default.WithVolume(-8f));
+                                Owner.EntityManager.SpawnEntity(_teleportQueue[0].Product, Owner.Transform.Coordinates);
+                                _teleportQueue.RemoveAt(0);
+                                if (Owner.TryGetComponent<SpriteComponent>(out var spriteComponent))
+                                    spriteComponent.LayerSetState(0, "idle");
+                                _currentState = CargoTelepadState.Idle;
+                                TeleportLoop();
+                            }
+                        });
+                    }
+                });
+            }
+        }
+
+        private enum CargoTelepadState { Unpowered, Idle, Charging, Teleporting };
+    }
+}

Content.Server/Cargo/Components/GalacticMarketComponent.cs

@@ -0,0 +1,15 @@
+using Content.Shared.Cargo.Components;
+using Robust.Shared.GameObjects;
+using Robust.Shared.Players;
+
+namespace Content.Server.Cargo.Components
+{
+    [RegisterComponent]
+    public class GalacticMarketComponent : SharedGalacticMarketComponent
+    {
+        public override ComponentState GetComponentState(ICommonSession player)
+        {
+            return new GalacticMarketState(GetProductIdList());
+        }
+    }
+}