(61d00a474) v0.9.7.1

2020-03-04 13:04:10 +01:00
parent 3c50efa5c9
commit 3c09ebe02f
5086 changed files with 786063 additions and 295871 deletions
@@ -0,0 +1,264 @@
+using Barotrauma.Extensions;
+using Barotrauma.Lights;
+using Barotrauma.Networking;
+using Microsoft.Xna.Framework;
+using Microsoft.Xna.Framework.Graphics;
+using System;
+
+namespace Barotrauma.Items.Components
+{
+    partial class Door : Pickable, IDrawableComponent, IServerSerializable
+    {
+        private ConvexHull convexHull;
+        private ConvexHull convexHull2;
+
+        private float shake;
+        private float shakeTimer;
+        private Vector2 shakePos;
+
+        //openState when the vertices of the convex hull were last calculated
+        private float lastConvexHullState;
+
+        [Serialize("1,1", false, description: "The scale of the shadow-casting area of the door (relative to the actual size of the door).")]
+        public Vector2 ShadowScale
+        {
+            get;
+            set;
+        }
+
+        public Vector2 DrawSize
+        {
+            //use the extents of the item as the draw size
+            get { return Vector2.Zero; }
+        }
+
+        private Vector2[] GetConvexHullCorners(Rectangle rect)
+        {
+            Point shadowSize = rect.Size.Multiply(ShadowScale);
+            Vector2 center = new Vector2(rect.Center.X, rect.Y - rect.Height / 2);
+
+            Vector2[] corners = new Vector2[4];
+            corners[0] = center + new Vector2(-shadowSize.X, -shadowSize.Y) / 2;
+            corners[1] = center + new Vector2(-shadowSize.X, shadowSize.Y) / 2;
+            corners[2] = center + new Vector2(shadowSize.X, shadowSize.Y) / 2;
+            corners[3] = center + new Vector2(shadowSize.X, -shadowSize.Y) / 2;
+
+            return corners;
+        }
+
+        private void UpdateConvexHulls()
+        {
+            doorRect = new Rectangle(
+                item.Rect.Center.X - (int)(doorSprite.size.X / 2 * item.Scale),
+                item.Rect.Y - item.Rect.Height / 2 + (int)(doorSprite.size.Y / 2.0f * item.Scale),
+                (int)(doorSprite.size.X * item.Scale),
+                (int)(doorSprite.size.Y * item.Scale));
+
+            Rectangle rect = doorRect;
+            if (IsHorizontal)
+            {
+                rect.Width = (int)(rect.Width * (1.0f - openState));
+            }
+            else
+            {
+                rect.Height = (int)(rect.Height * (1.0f - openState));
+            }
+
+            if (Window.Height > 0 && Window.Width > 0)
+            {
+                rect.Height = -(int)(Window.Y * item.Scale);
+
+                rect.Y += (int)(doorRect.Height * openState);
+                rect.Height = Math.Max(rect.Height - (rect.Y - doorRect.Y), 0);
+                rect.Y = Math.Min(doorRect.Y, rect.Y);
+                
+                if (convexHull2 != null)
+                {
+                    Rectangle rect2 = doorRect;
+                    rect2.Y += (int)(Window.Y * item.Scale - Window.Height * item.Scale);
+
+                    rect2.Y += (int)(doorRect.Height * openState);
+                    rect2.Y = Math.Min(doorRect.Y, rect2.Y);
+                    rect2.Height = rect2.Y - (doorRect.Y - (int)(doorRect.Height * (1.0f - openState)));
+
+                    if (rect2.Height == 0)
+                    {
+                        convexHull2.Enabled = false;
+                    }
+                    else
+                    {
+                        convexHull2.Enabled = true;
+                        convexHull2.SetVertices(GetConvexHullCorners(rect2));
+                    }
+                }
+            }
+            
+            if (convexHull == null) return;
+
+            if (rect.Height == 0 || rect.Width == 0)
+            {
+                convexHull.Enabled = false;
+            }
+            else
+            {
+                convexHull.Enabled = true;
+                convexHull.SetVertices(GetConvexHullCorners(rect));
+            }
+        }
+
+
+        partial void UpdateProjSpecific(float deltaTime)
+        {
+            if (shakeTimer > 0.0f)
+            {				
+                shakeTimer -= deltaTime;
+                Vector2 noisePos = new Vector2((float)PerlinNoise.CalculatePerlin(shakeTimer * 10.0f, shakeTimer * 10.0f, 0) - 0.5f, (float)PerlinNoise.CalculatePerlin(shakeTimer * 10.0f, shakeTimer * 10.0f, 0.5f) - 0.5f);
+                shakePos = noisePos * shake * 2.0f;
+                shake = Math.Min(shake, shakeTimer * 10.0f);
+            }
+            else
+            {
+                shakePos = Vector2.Zero;
+            }
+        }
+
+        public void Draw(SpriteBatch spriteBatch, bool editing, float itemDepth = -1)
+        {
+            Color color = item.SpriteColor;
+            if (brokenSprite == null)
+            {
+                //broken doors turn black if no broken sprite has been configured
+                color *= (item.Condition / item.Prefab.Health);
+                color.A = 255;
+            }
+            
+            if (stuck > 0.0f && weldedSprite != null)
+            {
+                Vector2 weldSpritePos = new Vector2(item.Rect.Center.X, item.Rect.Y - item.Rect.Height / 2.0f) + shakePos;
+                if (item.Submarine != null) weldSpritePos += item.Submarine.DrawPosition;
+                weldSpritePos.Y = -weldSpritePos.Y;
+
+                weldedSprite.Draw(spriteBatch,
+                    weldSpritePos, item.SpriteColor * (stuck / 100.0f), scale: item.Scale);
+            }
+
+            if (openState >= 1.0f)
+            {
+                return;
+            }
+
+            if (IsHorizontal)
+            {
+                Vector2 pos = new Vector2(item.Rect.X, item.Rect.Y - item.Rect.Height / 2) + shakePos;
+                if (item.Submarine != null) pos += item.Submarine.DrawPosition;
+                pos.Y = -pos.Y;
+
+                if (brokenSprite == null || !IsBroken)
+                {
+                    spriteBatch.Draw(doorSprite.Texture, pos,
+                        new Rectangle((int) (doorSprite.SourceRect.X + doorSprite.size.X * openState),
+                            (int) doorSprite.SourceRect.Y,
+                            (int) (doorSprite.size.X * (1.0f - openState)), (int) doorSprite.size.Y),
+                        color, 0.0f, doorSprite.Origin, item.Scale, SpriteEffects.None, doorSprite.Depth);
+                }
+
+                if (brokenSprite != null && item.Health < item.Prefab.Health)
+                {
+                    Vector2 scale = scaleBrokenSprite ? new Vector2(1.0f, 1.0f - item.Health / item.Prefab.Health) : Vector2.One;
+                    float alpha = fadeBrokenSprite ? 1.0f - item.Health / item.Prefab.Health : 1.0f;
+                    spriteBatch.Draw(brokenSprite.Texture, pos,
+                        new Rectangle((int)(brokenSprite.SourceRect.X + brokenSprite.size.X * openState), brokenSprite.SourceRect.Y,
+                            (int)(brokenSprite.size.X * (1.0f - openState)), (int)brokenSprite.size.Y),
+                        color * alpha, 0.0f, brokenSprite.Origin, scale * item.Scale, SpriteEffects.None,
+                        brokenSprite.Depth);
+                }
+            }
+            else
+            {
+                Vector2 pos = new Vector2(item.Rect.Center.X, item.Rect.Y) + shakePos;
+                if (item.Submarine != null) pos += item.Submarine.DrawPosition;
+                pos.Y = -pos.Y;
+
+                if (brokenSprite == null || !IsBroken)
+                {
+                    spriteBatch.Draw(doorSprite.Texture, pos,
+                        new Rectangle(doorSprite.SourceRect.X,
+                            (int) (doorSprite.SourceRect.Y + doorSprite.size.Y * openState),
+                            (int) doorSprite.size.X, (int) (doorSprite.size.Y * (1.0f - openState))),
+                        color, 0.0f, doorSprite.Origin, item.Scale, SpriteEffects.None, doorSprite.Depth);
+                }
+
+                if (brokenSprite != null && item.Health < item.Prefab.Health)
+                {
+                    Vector2 scale = scaleBrokenSprite ? new Vector2(1.0f - item.Health / item.Prefab.Health, 1.0f) : Vector2.One;
+                    float alpha = fadeBrokenSprite ? 1.0f - item.Health / item.Prefab.Health : 1.0f;
+                    spriteBatch.Draw(brokenSprite.Texture, pos,
+                        new Rectangle(brokenSprite.SourceRect.X, (int)(brokenSprite.SourceRect.Y + brokenSprite.size.Y * openState),
+                            (int)brokenSprite.size.X, (int)(brokenSprite.size.Y * (1.0f - openState))),
+                        color * alpha, 0.0f, brokenSprite.Origin, scale * item.Scale, SpriteEffects.None, brokenSprite.Depth);
+                }
+            }
+        }
+
+        partial void OnFailedToOpen()
+        {
+            if (shakeTimer <= 0.0f)
+            {
+                PlaySound(ActionType.OnFailure);
+                shake = 5.0f;
+                shakeTimer = 1.0f;
+            }
+        }
+
+        partial void SetState(bool open, bool isNetworkMessage, bool sendNetworkMessage, bool forcedOpen)
+        {
+            if ((IsStuck && !isNetworkMessage) ||
+                (PredictedState == null && isOpen == open) ||
+                (PredictedState != null && isOpen == PredictedState.Value && isOpen == open))
+            {
+                return;
+            }
+
+            if (GameMain.Client != null && !isNetworkMessage)
+            {
+                bool stateChanged = open != PredictedState;
+
+                //clients can "predict" that the door opens/closes when a signal is received
+                //the prediction will be reset after 1 second, setting the door to a state
+                //sent by the server, or reverting it back to its old state if no msg from server was received
+                PredictedState = open;
+                resetPredictionTimer = CorrectionDelay;
+                if (stateChanged) PlaySound(forcedOpen ? ActionType.OnPicked : ActionType.OnUse);
+            }
+            else
+            {
+                isOpen = open;
+                if (!isNetworkMessage || open != PredictedState)
+                {
+                    StopPicking(null);
+                    PlaySound(forcedOpen ? ActionType.OnPicked : ActionType.OnUse);
+                }
+            }       
+        }
+
+        public override void ClientRead(ServerNetObject type, IReadMessage msg, float sendingTime)
+        {
+            base.ClientRead(type, msg, sendingTime);
+
+            bool open = msg.ReadBoolean();
+            bool forcedOpen = msg.ReadBoolean();
+            SetState(open, isNetworkMessage: true, sendNetworkMessage: false, forcedOpen: forcedOpen);
+            Stuck = msg.ReadRangedSingle(0.0f, 100.0f, 8);
+            UInt16 lastUserID = msg.ReadUInt16();
+            Character user = lastUserID == 0 ? null : Entity.FindEntityByID(lastUserID) as Character;
+            if (user != lastUser)
+            {
+                lastUser = user;
+                toggleCooldownTimer = ToggleCoolDown;
+            }
+
+            if (isStuck) { OpenState = 0.0f; }
+            PredictedState = null;
+        }
+    }
+}