(61d00a474) v0.9.7.1

Barotrauma/BarotraumaServer/ServerSource/Items/Components/Machines/Controller.cs

@@ -0,0 +1,13 @@
+using Barotrauma.Networking;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Controller : ItemComponent, IServerSerializable
+    {
+        public void ServerWrite(IWriteMessage msg, Client c, object[] extraData = null)
+        {
+            msg.Write(state);
+            msg.Write(user == null ? (ushort)0 : user.ID);
+        }
+    }
+}

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

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

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

@@ -0,0 +1,32 @@
+using Barotrauma.Networking;
+using System;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Engine : Powered, IServerSerializable, IClientSerializable
+    {
+        public void ServerWrite(IWriteMessage msg, Client c, object[] extraData = null)
+        {
+            //force can only be adjusted at 10% intervals -> no need for more accuracy than this
+            msg.WriteRangedInteger((int)(targetForce / 10.0f), -10, 10);
+        }
+
+        public void ServerRead(ClientNetObject type, IReadMessage 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/ServerSource/Items/Components/Machines/Fabricator.cs

@@ -0,0 +1,42 @@
+using Barotrauma.Networking;
+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, IReadMessage msg, Client c)
+        {
+            int itemIndex = msg.ReadRangedInteger(-1, fabricationRecipes.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 && fabricationRecipes.IndexOf(fabricatedItem) == itemIndex) return;
+                if (itemIndex < 0 || itemIndex >= fabricationRecipes.Count) return;
+
+                StartFabricating(fabricationRecipes[itemIndex], c.Character);
+            }
+        }
+
+        public void ServerWrite(IWriteMessage msg, Client c, object[] extraData = null)
+        {
+            int itemIndex = fabricatedItem == null ? -1 : fabricationRecipes.IndexOf(fabricatedItem);
+            msg.WriteRangedInteger(itemIndex, -1, fabricationRecipes.Count - 1);
+            UInt16 userID = fabricatedItem == null || user == null ? (UInt16)0 : user.ID;
+            msg.Write(userID);
+        }
+    }
+}

Barotrauma/BarotraumaServer/ServerSource/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, IReadMessage 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(IWriteMessage msg, Client c, object[] extraData = null)
+        {
+            //flowpercentage can only be adjusted at 10% intervals -> no need for more accuracy than this
+            msg.WriteRangedInteger((int)(flowPercentage / 10.0f), -10, 10);
+            msg.Write(IsActive);
+        }
+    }
+}

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

@@ -0,0 +1,54 @@
+using Barotrauma.Networking;
+using System;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Reactor
+    {
+        private Client blameOnBroken;
+
+        private float? nextServerLogWriteTime;
+        private float lastServerLogWriteTime;
+
+        public void ServerRead(ClientNetObject type, IReadMessage msg, Client c)
+        {
+            bool autoTemp = msg.ReadBoolean();
+            bool powerOn = 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;
+
+            IsActive = true;
+
+            if (!autoTemp && AutoTemp) blameOnBroken = c;
+            if (turbineOutput < targetTurbineOutput) blameOnBroken = c;
+            if (fissionRate > targetFissionRate) blameOnBroken = c;
+            if (!_powerOn && powerOn) blameOnBroken = c;
+
+            AutoTemp = autoTemp;
+            _powerOn = powerOn;
+            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(IWriteMessage msg, Client c, object[] extraData = null)
+        {
+            msg.Write(autoTemp);
+            msg.Write(_powerOn);
+            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/ServerSource/Items/Components/Machines/Steering.cs

@@ -0,0 +1,115 @@
+using Barotrauma.Networking;
+using Microsoft.Xna.Framework;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Steering : Powered, IServerSerializable, IClientSerializable
+    {
+        // TODO: an enumeration would be much cleaner
+        public bool MaintainPos;
+        public bool LevelStartSelected;
+        public bool LevelEndSelected;
+
+        public bool UnsentChanges
+        {
+            get { return unsentChanges; }
+            set { unsentChanges = value; }
+        }
+
+
+        public void ServerRead(ClientNetObject type, IReadMessage msg, Barotrauma.Networking.Client c)
+        {
+            bool autoPilot = msg.ReadBoolean();
+            bool dockingButtonClicked = msg.ReadBoolean();
+            Vector2 newSteeringInput = targetVelocity;
+            bool maintainPos = false;
+            Vector2? newPosToMaintain = null;
+            bool headingToStart = false;
+
+            if (autoPilot)
+            {
+                maintainPos = msg.ReadBoolean();
+                if (maintainPos)
+                {
+                    newPosToMaintain = new Vector2(
+                        msg.ReadSingle(),
+                        msg.ReadSingle());
+                }
+                else
+                {
+                    headingToStart = msg.ReadBoolean();
+                }
+            }
+            else
+            {
+                newSteeringInput = new Vector2(msg.ReadSingle(), msg.ReadSingle());
+            }
+
+            if (!item.CanClientAccess(c)) return;
+
+            user = c.Character;
+            AutoPilot = autoPilot;
+
+            if (dockingButtonClicked)
+            {
+                item.SendSignal(0, "1", "toggle_docking", sender: null);
+                GameMain.Server.CreateEntityEvent(item, new object[] { NetEntityEvent.Type.ComponentState, item.GetComponentIndex(this), true });
+            }
+
+            if (!AutoPilot)
+            {
+                steeringInput = newSteeringInput;
+                steeringAdjustSpeed = MathHelper.Lerp(0.2f, 1.0f, c.Character.GetSkillLevel("helm") / 100.0f);
+            }
+            else
+            {
+                MaintainPos = newPosToMaintain != null;
+                posToMaintain = newPosToMaintain;
+
+                if (posToMaintain == null)
+                {
+                    LevelStartSelected = headingToStart;
+                    LevelEndSelected = !headingToStart;
+                    UpdatePath();
+                }
+                else
+                {
+                    LevelStartSelected = false;
+                    LevelEndSelected = false;
+                }
+            }
+
+            //notify all clients of the changed state
+            unsentChanges = true;
+        }
+
+        public void ServerWrite(IWriteMessage msg, Barotrauma.Networking.Client c, object[] extraData = null)
+        {
+            msg.Write(autoPilot);
+            msg.Write(extraData.Length > 2 && extraData[2] is bool && (bool)extraData[2]);
+
+            if (!autoPilot)
+            {
+                //no need to write steering info if autopilot is controlling
+                msg.Write(steeringInput.X);
+                msg.Write(steeringInput.Y);
+                msg.Write(targetVelocity.X);
+                msg.Write(targetVelocity.Y);
+                msg.Write(steeringAdjustSpeed);
+            }
+            else
+            {
+                msg.Write(posToMaintain != null);
+                if (posToMaintain != null)
+                {
+                    msg.Write(((Vector2)posToMaintain).X);
+                    msg.Write(((Vector2)posToMaintain).Y);
+                }
+                else
+                {
+                    msg.Write(LevelStartSelected);
+                }
+            }
+        }
+    }
+}