2f107db...5202af9

Barotrauma/BarotraumaServer/Source/Items/Components/Door.cs

@@ -0,0 +1,33 @@
+using Microsoft.Xna.Framework;
+using Barotrauma.Networking;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Door
+    {
+        partial void SetState(bool open, bool isNetworkMessage, bool sendNetworkMessage)
+        {
+            if (isStuck || isOpen == open)
+            {
+                return;
+            }
+            isOpen = open;
+
+            //opening a partially stuck door makes it less stuck
+            if (isOpen) stuck = MathHelper.Clamp(stuck - 30.0f, 0.0f, 100.0f);
+
+            if (sendNetworkMessage)
+            {
+                item.CreateServerEvent(this);
+            }
+        }
+
+        public override void ServerWrite(Lidgren.Network.NetBuffer msg, Client c, object[] extraData = null)
+        {
+            base.ServerWrite(msg, c, extraData);
+
+            msg.Write(isOpen);
+            msg.WriteRangedSingle(stuck, 0.0f, 100.0f, 8);
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Items/Components/Machines/Deconstructor.cs

@@ -0,0 +1,27 @@
+using Barotrauma.Networking;
+using Lidgren.Network;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Deconstructor : Powered, IServerSerializable, IClientSerializable
+    {
+        public void ServerRead(ClientNetObject type, NetBuffer msg, Client c)
+        {
+            bool active = msg.ReadBoolean();
+
+            item.CreateServerEvent(this);
+
+            if (item.CanClientAccess(c))
+            {
+                SetActive(active, c.Character);
+            }
+        }
+
+        public void ServerWrite(NetBuffer msg, Client c, object[] extraData = null)
+        {
+            msg.Write(IsActive);
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Items/Components/Machines/Engine.cs

@@ -0,0 +1,36 @@
+using Microsoft.Xna.Framework;
+using System;
+using System.Globalization;
+using System.Xml.Linq;
+using Barotrauma.Networking;
+using Lidgren.Network;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Engine : Powered, IServerSerializable, IClientSerializable
+    {
+        public void ServerWrite(NetBuffer msg, Client c, object[] extraData = null)
+        {
+            //force can only be adjusted at 10% intervals -> no need for more accuracy than this
+            msg.WriteRangedInteger(-10, 10, (int)(targetForce / 10.0f));
+        }
+
+        public void ServerRead(ClientNetObject type, NetBuffer msg, Client c)
+        {
+            float newTargetForce = msg.ReadRangedInteger(-10, 10) * 10.0f;
+
+            if (item.CanClientAccess(c))
+            {
+                if (Math.Abs(newTargetForce - targetForce) > 0.01f)
+                {
+                    GameServer.Log(c.Character.LogName + " set the force of " + item.Name + " to " + (int)(newTargetForce) + " %", ServerLog.MessageType.ItemInteraction);
+                }
+
+                targetForce = newTargetForce;
+            }
+
+            //notify all clients of the changed state
+            item.CreateServerEvent(this);
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Items/Components/Machines/Fabricator.cs

@@ -0,0 +1,43 @@
+using Barotrauma.Networking;
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Fabricator : Powered, IServerSerializable, IClientSerializable
+    {
+        public void ServerRead(ClientNetObject type, NetBuffer msg, Client c)
+        {
+            int itemIndex = msg.ReadRangedInteger(-1, fabricableItems.Count - 1);
+
+            item.CreateServerEvent(this);
+
+            if (!item.CanClientAccess(c)) return;
+
+            if (itemIndex == -1)
+            {
+                CancelFabricating(c.Character);
+            }
+            else
+            {
+                //if already fabricating the selected item, return
+                if (fabricatedItem != null && fabricableItems.IndexOf(fabricatedItem) == itemIndex) return;
+                if (itemIndex < 0 || itemIndex >= fabricableItems.Count) return;
+
+                StartFabricating(fabricableItems[itemIndex], c.Character);
+            }
+        }
+
+        public void ServerWrite(NetBuffer msg, Client c, object[] extraData = null)
+        {
+            int itemIndex = fabricatedItem == null ? -1 : fabricableItems.IndexOf(fabricatedItem);
+            msg.WriteRangedInteger(-1, fabricableItems.Count - 1, itemIndex);
+            UInt16 userID = fabricatedItem == null || user == null ? (UInt16)0 : user.ID;
+            msg.Write(userID);
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Items/Components/Machines/Pump.cs

@@ -0,0 +1,42 @@
+using Barotrauma.Networking;
+using Microsoft.Xna.Framework;
+using System;
+using System.Globalization;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Pump : Powered, IServerSerializable, IClientSerializable
+    {
+        public void ServerRead(ClientNetObject type, Lidgren.Network.NetBuffer msg, Client c)
+        {
+            float newFlowPercentage = msg.ReadRangedInteger(-10, 10) * 10.0f;
+            bool newIsActive = msg.ReadBoolean();
+
+            if (item.CanClientAccess(c))
+            {
+                if (newFlowPercentage != FlowPercentage)
+                {
+                    GameServer.Log(c.Character.LogName + " set the pumping speed of " + item.Name + " to " + (int)(newFlowPercentage) + " %", ServerLog.MessageType.ItemInteraction);
+                }
+                if (newIsActive != IsActive)
+                {
+                    GameServer.Log(c.Character.LogName + (newIsActive ? " turned on " : " turned off ") + item.Name, ServerLog.MessageType.ItemInteraction);
+                }
+
+                FlowPercentage = newFlowPercentage;
+                IsActive = newIsActive;
+            }
+
+            //notify all clients of the changed state
+            item.CreateServerEvent(this);
+        }
+
+        public void ServerWrite(Lidgren.Network.NetBuffer msg, Client c, object[] extraData = null)
+        {
+            //flowpercentage can only be adjusted at 10% intervals -> no need for more accuracy than this
+            msg.WriteRangedInteger(-10, 10, (int)(flowPercentage / 10.0f));
+            msg.Write(IsActive);
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Items/Components/Machines/Reactor.cs

@@ -0,0 +1,53 @@
+using Barotrauma.Networking;
+using Lidgren.Network;
+using System;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Reactor
+    {
+        private Client blameOnBroken;
+
+        private float? nextServerLogWriteTime;
+        private float lastServerLogWriteTime;
+
+        public void ServerRead(ClientNetObject type, NetBuffer msg, Client c)
+        {
+            bool autoTemp = msg.ReadBoolean();
+            bool shutDown = msg.ReadBoolean();
+            float fissionRate = msg.ReadRangedSingle(0.0f, 100.0f, 8);
+            float turbineOutput = msg.ReadRangedSingle(0.0f, 100.0f, 8);
+
+            if (!item.CanClientAccess(c)) return;
+
+            if (!autoTemp && AutoTemp) blameOnBroken = c;
+            if (turbineOutput < targetTurbineOutput) blameOnBroken = c;
+            if (fissionRate > targetFissionRate) blameOnBroken = c;
+            if (!this.shutDown && shutDown) blameOnBroken = c;
+
+            AutoTemp = autoTemp;
+            this.shutDown = shutDown;
+            targetFissionRate = fissionRate;
+            targetTurbineOutput = turbineOutput;
+
+            LastUser = c.Character;
+            if (nextServerLogWriteTime == null)
+            {
+                nextServerLogWriteTime = Math.Max(lastServerLogWriteTime + 1.0f, (float)Timing.TotalTime);
+            }
+
+            //need to create a server event to notify all clients of the changed state
+            unsentChanges = true;
+        }
+
+        public void ServerWrite(NetBuffer msg, Client c, object[] extraData = null)
+        {
+            msg.Write(autoTemp);
+            msg.Write(shutDown);
+            msg.WriteRangedSingle(temperature, 0.0f, 100.0f, 8);
+            msg.WriteRangedSingle(targetFissionRate, 0.0f, 100.0f, 8);
+            msg.WriteRangedSingle(targetTurbineOutput, 0.0f, 100.0f, 8);
+            msg.WriteRangedSingle(degreeOfSuccess, 0.0f, 1.0f, 8);
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Items/Components/Power/PowerContainer.cs

@@ -0,0 +1,32 @@
+using Barotrauma.Networking;
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using System;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class PowerContainer : Powered, IDrawableComponent, IServerSerializable, IClientSerializable
+    {
+        public void ServerRead(ClientNetObject type, NetBuffer msg, Client c)
+        {
+            float newRechargeSpeed = msg.ReadRangedInteger(0, 10) / 10.0f * maxRechargeSpeed;
+
+            if (item.CanClientAccess(c))
+            {
+                RechargeSpeed = newRechargeSpeed;
+                GameServer.Log(c.Character.LogName + " set the recharge speed of " + item.Name + " to " + (int)((rechargeSpeed / maxRechargeSpeed) * 100.0f) + " %", ServerLog.MessageType.ItemInteraction);
+            }
+
+            item.CreateServerEvent(this);
+        }
+
+        public void ServerWrite(NetBuffer msg, Client c, object[] extraData = null)
+        {
+            msg.WriteRangedInteger(0, 10, (int)(rechargeSpeed / MaxRechargeSpeed * 10));
+
+            float chargeRatio = MathHelper.Clamp(charge / capacity, 0.0f, 1.0f);
+            msg.WriteRangedSingle(chargeRatio, 0.0f, 1.0f, 8);
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Items/Components/Repairable.cs

@@ -0,0 +1,18 @@
+using Barotrauma.Networking;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Repairable : ItemComponent, IServerSerializable, IClientSerializable
+    {
+        void InitProjSpecific()
+        {
+            //let the clients know the initial deterioration delay
+            item.CreateServerEvent(this);
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Items/Components/Signal/ConnectionPanel.cs

@@ -0,0 +1,153 @@
+using Barotrauma.Networking;
+using FarseerPhysics;
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class ConnectionPanel : ItemComponent, IServerSerializable, IClientSerializable
+    {
+        public void ServerRead(ClientNetObject type, NetBuffer msg, Client c)
+        {
+            List<Wire>[] wires = new List<Wire>[Connections.Count];
+
+            //read wire IDs for each connection
+            for (int i = 0; i < Connections.Count; i++)
+            {
+                wires[i] = new List<Wire>();
+                for (int j = 0; j < Connection.MaxLinked; j++)
+                {
+                    ushort wireId = msg.ReadUInt16();
+
+                    Item wireItem = Entity.FindEntityByID(wireId) as Item;
+                    if (wireItem == null) continue;
+
+                    Wire wireComponent = wireItem.GetComponent<Wire>();
+                    if (wireComponent != null)
+                    {
+                        wires[i].Add(wireComponent);
+                    }
+                }
+            }
+
+            //don't allow rewiring locked panels
+            if (Locked) return;
+
+            item.CreateServerEvent(this);
+
+            //check if the character can access this connectionpanel 
+            //and all the wires they're trying to connect
+            if (!item.CanClientAccess(c)) return;
+            for (int i = 0; i < Connections.Count; i++)
+            {
+                foreach (Wire wire in wires[i])
+                {
+                    //wire not found in any of the connections yet (client is trying to connect a new wire)
+                    //  -> we need to check if the client has access to it
+                    if (!Connections.Any(connection => connection.Wires.Contains(wire)))
+                    {
+                        if (!wire.Item.CanClientAccess(c)) return;
+                    }
+                }
+            }
+
+            //go through existing wire links
+            for (int i = 0; i < Connections.Count; i++)
+            {
+                int j = -1;
+                foreach (Wire existingWire in Connections[i].Wires)
+                {
+                    j++;
+                    if (existingWire == null) continue;
+
+                    //existing wire not in the list of new wires -> disconnect it
+                    if (!wires[i].Contains(existingWire))
+                    {
+                        if (existingWire.Locked)
+                        {
+                            //this should not be possible unless the client is running a modified version of the game
+                            GameServer.Log(c.Character.LogName + " attempted to disconnect a locked wire from " +
+                                Connections[i].Item.Name + " (" + Connections[i].Name + ")", ServerLog.MessageType.Error);
+                            continue;
+                        }
+
+                        existingWire.RemoveConnection(item);
+
+                        if (existingWire.Connections[0] == null && existingWire.Connections[1] == null)
+                        {
+                            GameServer.Log(c.Character.LogName + " disconnected a wire from " +
+                                Connections[i].Item.Name + " (" + Connections[i].Name + ")", ServerLog.MessageType.ItemInteraction);
+                        }
+                        else if (existingWire.Connections[0] != null)
+                        {
+                            GameServer.Log(c.Character.LogName + " disconnected a wire from " +
+                                Connections[i].Item.Name + " (" + Connections[i].Name + ") to " + existingWire.Connections[0].Item.Name + " (" + existingWire.Connections[0].Name + ")", ServerLog.MessageType.ItemInteraction);
+
+                            //wires that are not in anyone's inventory (i.e. not currently being rewired) 
+                            //can never be connected to only one connection
+                            // -> the client must have dropped the wire from the connection panel
+                            if (existingWire.Item.ParentInventory == null && !wires.Any(w => w.Contains(existingWire)))
+                            {
+                                //let other clients know the item was also disconnected from the other connection
+                                existingWire.Connections[0].Item.CreateServerEvent(existingWire.Connections[0].Item.GetComponent<ConnectionPanel>());
+                                existingWire.Item.Drop(c.Character);
+                            }
+                        }
+                        else if (existingWire.Connections[1] != null)
+                        {
+                            GameServer.Log(c.Character.LogName + " disconnected a wire from " +
+                                Connections[i].Item.Name + " (" + Connections[i].Name + ") to " + existingWire.Connections[1].Item.Name + " (" + existingWire.Connections[1].Name + ")", ServerLog.MessageType.ItemInteraction);
+
+                            if (existingWire.Item.ParentInventory == null && !wires.Any(w => w.Contains(existingWire)))
+                            {
+                                //let other clients know the item was also disconnected from the other connection
+                                existingWire.Connections[1].Item.CreateServerEvent(existingWire.Connections[1].Item.GetComponent<ConnectionPanel>());
+                                existingWire.Item.Drop(c.Character);
+                            }
+                        }
+
+                        Connections[i].SetWire(j, null);
+                    }
+                }
+            }
+
+            //go through new wires
+            for (int i = 0; i < Connections.Count; i++)
+            {
+                foreach (Wire newWire in wires[i])
+                {
+                    //already connected, no need to do anything
+                    if (Connections[i].Wires.Contains(newWire)) continue;
+
+                    Connections[i].TryAddLink(newWire);
+                    newWire.Connect(Connections[i], true, true);
+
+                    var otherConnection = newWire.OtherConnection(Connections[i]);
+
+                    if (otherConnection == null)
+                    {
+                        GameServer.Log(c.Character.LogName + " connected a wire to " +
+                            Connections[i].Item.Name + " (" + Connections[i].Name + ")",
+                            ServerLog.MessageType.ItemInteraction);
+                    }
+                    else
+                    {
+                        GameServer.Log(c.Character.LogName + " connected a wire from " +
+                            Connections[i].Item.Name + " (" + Connections[i].Name + ") to " +
+                            (otherConnection == null ? "none" : otherConnection.Item.Name + " (" + (otherConnection.Name) + ")"),
+                            ServerLog.MessageType.ItemInteraction);
+                    }
+                }
+            }
+        }
+
+        public void ServerWrite(NetBuffer msg, Client c, object[] extraData = null)
+        {
+            ClientWrite(msg, extraData);
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Items/Components/Signal/CustomInterface.cs

@@ -0,0 +1,63 @@
+using Barotrauma.Networking;
+using Lidgren.Network;
+using System.Collections.Generic;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class CustomInterface : ItemComponent, IClientSerializable, IServerSerializable
+    {
+        public void ServerRead(ClientNetObject type, NetBuffer msg, Client c)
+        {
+            bool[] elementStates = new bool[customInterfaceElementList.Count];
+            for (int i = 0; i < customInterfaceElementList.Count; i++)
+            {
+                elementStates[i] = msg.ReadBoolean();
+            }
+
+            CustomInterfaceElement clickedButton = null;
+            if (item.CanClientAccess(c))
+            {
+                for (int i = 0; i < customInterfaceElementList.Count; i++)
+                {
+                    if (customInterfaceElementList[i].ContinuousSignal)
+                    {
+                        TickBoxToggled(customInterfaceElementList[i], elementStates[i]);
+                    }
+                    else if (elementStates[i])
+                    {
+                        clickedButton = customInterfaceElementList[i];
+                        ButtonClicked(customInterfaceElementList[i]);
+                    }
+                }
+            }
+
+            //notify all clients of the new state
+            GameMain.Server.CreateEntityEvent(item, new object[]
+            {
+                NetEntityEvent.Type.ComponentState,
+                item.GetComponentIndex(this),
+                clickedButton
+            });
+
+            item.CreateServerEvent(this);
+        }
+
+        public void ServerWrite(NetBuffer msg, Client c, object[] extraData = null)
+        {
+            //extradata contains an array of buttons clicked by a client (or nothing if nothing was clicked)
+            for (int i = 0; i < customInterfaceElementList.Count; i++)
+            {
+                if (customInterfaceElementList[i].ContinuousSignal)
+                {
+                    msg.Write(customInterfaceElementList[i].State);
+                }
+                else
+                {
+                    msg.Write(extraData != null && extraData.Any(d => d as CustomInterfaceElement == customInterfaceElementList[i]));
+                }
+            }
+        }
+    }
+}

Barotrauma/BarotraumaServer/Source/Items/Components/Signal/Wire.cs

@@ -0,0 +1,41 @@
+using Barotrauma.Networking;
+using Lidgren.Network;
+using Microsoft.Xna.Framework;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Xml.Linq;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Wire : ItemComponent, IDrawableComponent, IServerSerializable
+    {
+        private void CreateNetworkEvent()
+        {
+            if (GameMain.Server == null) return;
+            //split into multiple events because one might not be enough to fit all the nodes
+            int eventCount = Math.Max((int)Math.Ceiling(nodes.Count / (float)MaxNodesPerNetworkEvent), 1);
+            for (int i = 0; i < eventCount; i++)
+            {
+                GameMain.Server.CreateEntityEvent(item, new object[] { NetEntityEvent.Type.ComponentState, item.GetComponentIndex(this), i });
+            }
+
+        }
+
+        public void ServerWrite(NetBuffer msg, Client c, object[] extraData = null)
+        {
+            int eventIndex = (int)extraData[2];
+            int nodeStartIndex = eventIndex * MaxNodesPerNetworkEvent;
+            int nodeCount = MathHelper.Clamp(nodes.Count - nodeStartIndex, 0, MaxNodesPerNetworkEvent);
+
+            msg.WriteRangedInteger(0, (int)Math.Ceiling(MaxNodeCount / (float)MaxNodesPerNetworkEvent), eventIndex);
+            msg.WriteRangedInteger(0, MaxNodesPerNetworkEvent, nodeCount);
+            for (int i = nodeStartIndex; i < nodeStartIndex + nodeCount; i++)
+            {
+                msg.Write(nodes[i].X);
+                msg.Write(nodes[i].Y);
+            }
+        }
+    }
+}