Bump up tile friction (#4329)

* Bump up tile friction

* Increase throwing speed

* Fix ExplosionLaunched throwing

* Flying time

Content.Server/Explosion/Components/ExplosionLaunchedComponent.cs

@@ -16,6 +16,9 @@ namespace Content.Server.Explosion.Components
 
             var sourceLocation = eventArgs.Source;
             var targetLocation = eventArgs.Target.Transform.Coordinates;
+
+            if (sourceLocation.Equals(targetLocation)) return;
+
             var direction = (targetLocation.ToMapPos(Owner.EntityManager) - sourceLocation.ToMapPos(Owner.EntityManager)).Normalized;
 
             var throwForce = eventArgs.Severity switch
@@ -24,7 +27,8 @@ namespace Content.Server.Explosion.Components
                 ExplosionSeverity.Light => 20,
                 _ => 0,
             };
-            Owner.TryThrow(direction * throwForce);
+            
+            Owner.TryThrow(direction, throwForce);
         }
     }
 }

Content.Server/Hands/HandsSystem.cs

@@ -132,8 +132,10 @@ namespace Content.Server.Hands
             if (direction == Vector2.Zero)
                 return true;
 
-            var throwVec = direction.Normalized * MathF.Min(direction.Length, hands.ThrowRange) * hands.ThrowForceMultiplier;
+            direction = direction.Normalized * Math.Min(direction.Length, hands.ThrowRange);
-            throwEnt.TryThrow(throwVec, playerEnt);
+
+            var throwStrength = hands.ThrowForceMultiplier;
+            throwEnt.TryThrow(direction, throwStrength, playerEnt);
 
             return true;
         }

Content.Server/Throwing/ThrowHelper.cs

@@ -8,23 +8,34 @@ using Robust.Shared.GameObjects;
 using Robust.Shared.Log;
 using Robust.Shared.Maths;
 using Robust.Shared.Physics;
+using Robust.Shared.Timing;
 
 namespace Content.Server.Throwing
 {
     internal static class ThrowHelper
     {
-        private const float ThrowAngularImpulse = 3.0f;
+        private const float ThrowAngularImpulse = 1.5f;
+
+        /// <summary>
+        /// The minimum amount of time an entity needs to be thrown before the timer can be run.
+        /// Anything below this threshold never enters the air.
+        /// </summary>
+        private const float FlyTime = 0.15f;
 
         /// <summary>
         ///     Tries to throw the entity if it has a physics component, otherwise does nothing.
         /// </summary>
-        /// <param name="entity"></param>
+        /// <param name="entity">The entity being thrown.</param>
-        /// <param name="direction">Will use the vector's magnitude as the strength of the impulse</param>
+        /// <param name="direction">A vector pointing from the entity to its destination.</param>
+        /// <param name="strength">How much the direction vector should be multiplied for velocity.</param>
         /// <param name="user"></param>
         /// <param name="pushbackRatio">The ratio of impulse applied to the thrower</param>
-        internal static void TryThrow(this IEntity entity, Vector2 direction, IEntity? user = null, float pushbackRatio = 1.0f)
+        internal static void TryThrow(this IEntity entity, Vector2 direction, float strength = 1.0f, IEntity? user = null, float pushbackRatio = 1.0f)
         {
-            if (entity.Deleted || direction == Vector2.Zero || !entity.TryGetComponent(out PhysicsComponent? physicsComponent))
+            if (entity.Deleted ||
+                direction == Vector2.Zero ||
+                strength <= 0f ||
+                !entity.TryGetComponent(out PhysicsComponent? physicsComponent))
             {
                 return;
             }
@@ -58,7 +69,25 @@ namespace Content.Server.Throwing
                     EntitySystem.Get<InteractionSystem>().ThrownInteraction(user, entity);
             }
 
-            physicsComponent.ApplyLinearImpulse(direction);
+            physicsComponent.ApplyLinearImpulse(direction.Normalized * strength * physicsComponent.Mass);
+            // Estimate time to arrival so we can apply OnGround status and slow it much faster.
+            var time = (direction / strength).Length;
+
+            if (time < FlyTime)
+            {
+                physicsComponent.BodyStatus = BodyStatus.OnGround;
+            }
+            else
+            {
+                physicsComponent.BodyStatus = BodyStatus.InAir;
+
+                Timer.Spawn(TimeSpan.FromSeconds(time - FlyTime), () =>
+                {
+                    if (physicsComponent.Deleted) return;
+                    physicsComponent.BodyStatus = BodyStatus.OnGround;
+                });
+            }
+
             // Give thrower an impulse in the other direction
             if (user != null && pushbackRatio > 0.0f && user.TryGetComponent(out IPhysBody? body))
             {

Content.Shared/CCVar/CCVars.cs

@@ -176,10 +176,10 @@ namespace Content.Shared.CCVar
          */
 
         public static readonly CVarDef<float> TileFrictionModifier =
-            CVarDef.Create("physics.tilefriction", 15.0f);
+            CVarDef.Create("physics.tile_friction", 40.0f);
 
         public static readonly CVarDef<float> StopSpeed =
-            CVarDef.Create("physics.stopspeed", 0.1f);
+            CVarDef.Create("physics.stop_speed", 0.1f);
 
         /*
          * Ambience

Content.Shared/Hands/Components/SharedHandsComponent.cs

@@ -66,7 +66,7 @@ namespace Content.Shared.Hands.Components
         /// </summary>
         [DataField("throwForceMultiplier")]
         [ViewVariables(VVAccess.ReadWrite)]
-        public float ThrowForceMultiplier { get; set; } = 14f; //should be tuned so that a thrown item lands about under the player's cursor
+        public float ThrowForceMultiplier { get; set; } = 10f; //should be tuned so that a thrown item lands about under the player's cursor
 
         /// <summary>
         ///     Distance after which longer throw targets stop increasing throw impulse.