Physics (#3485)

* Content side new physics structure * BroadPhase outline done * But we need to fix WorldAABB * Fix static pvs AABB * Fix import * Rando fixes * B is for balloon * Change human mob hitbox to circle * Decent movement * Start adding friction to player controller I think it's the best way to go about it to keep other objects somewhat consistent for physics. * This baby can fit so many physics bugs in it. * Slight mob mover optimisations. * Player mover kinda works okay. * Beginnings of testbed * More testbed * Circlestack bed * Namespaces * BB fixes * Pull WorldAABB * Joint pulling * Semi-decent movement I guess. * Pulling better * Bullet controller + old movement * im too dumb for this shit * Use kinematic mob controller again It's probably for the best TBH * Stashed shitcode * Remove SlipController * In which movement code is entirely refactored * Singularity fix * Fix ApplyLinearImpulse * MoveRelay fix * Fix door collisions * Disable subfloor collisions Saves on broadphase a fair bit * Re-implement ClimbController * Zumzum's pressure * Laggy item throwing * Minor atmos change * Some caching * Optimise controllers * Optimise CollideWith to hell and back * Re-do throwing and tile friction * Landing too * Optimise controllers * Move CCVars and other stuff swept is beautiful * Cleanup a bunch of controllers * Fix shooting and high pressure movement controller * Flashing improvements * Stuff and things * Combat collisions * Combat mode collisions * Pulling distance joint again * Cleanup physics interfaces * More like scuffedularity * Shit's fucked * Haha tests go green * Bigmoneycrab * Fix dupe pulling * Zumzum's based fix * Don't run tile friction for non-predicted bodies * Experimental pulling improvement * Everything's a poly now * Optimise AI region debugging a bit Could still be better but should improve default performance a LOT * Mover no updater * Crazy kinematic body idea * Good collisions * KinematicController * Fix aghost * Throwing refactor * Pushing cleanup * Fix throwing and footstep sounds * Frametime in ICollideBehavior * Fix stuff * Actually fix weightlessness * Optimise collision behaviors a lot * Make open lockers still collide with walls * powwweeerrrrr * Merge master proper * AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA * AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA * AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA * Ch ch ch changesss * SHIP IT * Fix #if DEBUG * Fix vaulting and item locker collision * Fix throwing * Editing yaml by hand what can go wrong * on * Last yaml fixes * Okay now it's fixed * Linter Co-authored-by: Metal Gear Sloth <metalgearsloth@gmail.com> Co-authored-by: Vera Aguilera Puerto <zddm@outlook.es>
2021-03-08 04:09:59 +11:00
parent 217e8c0ba2
commit 4d064abcd7
237 changed files with 3365 additions and 2880 deletions
--- a/Content.Shared/Physics/Controllers/SharedTileFrictionController.cs
+++ b/Content.Shared/Physics/Controllers/SharedTileFrictionController.cs
@@ -0,0 +1,102 @@
+using System;
+using Content.Shared.GameObjects.Components.Mobs.State;
+using Content.Shared.GameObjects.Components.Movement;
+using Content.Shared.GameObjects.EntitySystems.ActionBlocker;
+using JetBrains.Annotations;
+using Robust.Shared;
+using Robust.Shared.Configuration;
+using Robust.Shared.GameObjects;
+using Robust.Shared.IoC;
+using Robust.Shared.Map;
+using Robust.Shared.Physics;
+using Robust.Shared.Physics.Broadphase;
+using Robust.Shared.Physics.Controllers;
+using Robust.Shared.Physics.Dynamics;
+
+#nullable enable
+
+namespace Content.Shared.Physics.Controllers
+{
+    public sealed class SharedTileFrictionController : VirtualController
+    {
+        [Dependency] private readonly IConfigurationManager _configManager = default!;
+        [Dependency] private readonly IMapManager _mapManager = default!;
+        [Dependency] private readonly IPhysicsManager _physicsManager = default!;
+        [Dependency] private readonly ITileDefinitionManager _tileDefinitionManager = default!;
+
+        private SharedBroadPhaseSystem _broadPhaseSystem = default!;
+
+        private float _stopSpeed;
+
+        private float _frictionModifier;
+
+        public override void Initialize()
+        {
+            base.Initialize();
+            _broadPhaseSystem = EntitySystem.Get<SharedBroadPhaseSystem>();
+
+            _frictionModifier = _configManager.GetCVar(CCVars.TileFrictionModifier);
+            _configManager.OnValueChanged(CCVars.TileFrictionModifier, value => _frictionModifier = value);
+
+            _stopSpeed = _configManager.GetCVar(CCVars.StopSpeed);
+            _configManager.OnValueChanged(CCVars.StopSpeed, value => _stopSpeed = value);
+        }
+
+        public override void UpdateBeforeMapSolve(bool prediction, PhysicsMap map, float frameTime)
+        {
+            base.UpdateBeforeMapSolve(prediction, map, frameTime);
+
+            foreach (var body in map.AwakeBodies)
+            {
+                if (prediction && !body.Predict) continue;
+
+                var speed = body.LinearVelocity.Length;
+
+                if (speed <= 0.0f || body.BodyStatus == BodyStatus.InAir) continue;
+
+                // This is the *actual* amount that speed will drop by, we just do some multiplication around it to be easier.
+                var drop = 0.0f;
+                float control;
+
+                // Only apply friction when it's not a mob (or the mob doesn't have control).
+                if (SharedMoverController.UseMobMovement(_broadPhaseSystem, body, _physicsManager)) continue;
+
+                var surfaceFriction = GetTileFriction(body);
+                var bodyModifier = body.Owner.GetComponentOrNull<SharedTileFrictionModifier>()?.Modifier ?? 1.0f;
+                var friction = _frictionModifier * surfaceFriction * bodyModifier;
+
+                if (friction > 0.0f)
+                {
+                    // TBH I can't really tell if this makes a difference.
+                    if (!prediction)
+                    {
+                        control = speed < _stopSpeed ? _stopSpeed : speed;
+                    }
+                    else
+                    {
+                        control = speed;
+                    }
+
+                    drop += control * friction * frameTime;
+                }
+
+                var newSpeed = MathF.Max(0.0f, speed - drop);
+
+                newSpeed /= speed;
+                body.LinearVelocity *= newSpeed;
+            }
+        }
+
+        [Pure]
+        private float GetTileFriction(IPhysBody body)
+        {
+            // TODO: Make IsWeightless event-based; we already have grid traversals tracked so just raise events
+            if (body.BodyStatus == BodyStatus.InAir || body.Owner.IsWeightless(_physicsManager) || !_mapManager.TryGetGrid(body.Owner.Transform.GridID, out var grid))
+                return 0.0f;
+
+            var tile = grid.GetTileRef(body.Owner.Transform.Coordinates);
+            var tileDef = _tileDefinitionManager[tile.Tile.TypeId];
+            return tileDef.Friction;
+        }
+    }
+}