major rework

2026-02-16 18:32:48 +01:00
parent bbd82da07e
commit 932734e5b4
24 changed files with 1706 additions and 893 deletions
--- a/simulation/Core/Components/Engine.cs
+++ b/simulation/Core/Components/Engine.cs
@@ -0,0 +1,163 @@
+using Car_simulation.Core.Physics;
+
+namespace Car_simulation.Core.Components
+{
+    public class Engine : ICarComponent
+    {
+        // Energy state
+        public float FlywheelEnergy { get; set; }
+
+        // Physical properties
+        public float MomentOfInertia { get; set; } = 0.25f;
+        public float IdleRPM { get; set; } = 800f;
+        public float RevLimit { get; set; } = 7000;
+        public float StallSpeed { get; set; } = 200f;
+        public float Throttle { get; set; } = 0f;
+        public bool IsRunning => RPM > StallSpeed;
+
+        private float _cutoffUntil = 0;
+        private bool _cutoff = false;
+
+        // Torque curve
+        private TorqueCurve _torqueCurve;
+
+        public Engine()
+        {
+            FlywheelEnergy = GetEnergyFromRPM(IdleRPM);
+            _torqueCurve = new TorqueCurve();
+            InitializeDefaultCurve();
+        }
+
+        private void InitializeDefaultCurve()
+        {
+            _torqueCurve.AddPoint(0f, 0f);
+            _torqueCurve.AddPoint(800f, 95f);
+            _torqueCurve.AddPoint(1500f, 160f);
+            _torqueCurve.AddPoint(2500f, 200f);
+            _torqueCurve.AddPoint(4000f, 235f);
+            _torqueCurve.AddPoint(5000f, 230f);
+            _torqueCurve.AddPoint(6000f, 210f);
+            _torqueCurve.AddPoint(6800f, 185f);
+            _torqueCurve.AddPoint(7200f, 170f);
+        }
+
+        public float RPM => GetRPM();
+        public float AngularVelocity => GetOmega();
+        public float CurrentPower { get; private set; }
+
+        public void Update(float deltaTime)
+        {
+            // Engine updates are now handled through Car with totalTime parameter
+        }
+
+        public void UpdateWithTime(float deltaTime, float totalTime)
+        {
+            UpdateRevLimiter(totalTime);
+
+            float combustionEnergy = CalculateCombustionPower(deltaTime);
+            float frictionLoss = CalculateFrictionLoss(deltaTime);
+            float netEnergy = combustionEnergy - frictionLoss;
+
+            CurrentPower = netEnergy / deltaTime;
+            FlywheelEnergy += netEnergy;
+
+            // Stall protection
+            float stallEnergy = GetEnergyFromRPM(StallSpeed);
+            if (FlywheelEnergy < stallEnergy && Throttle > 0.1f)
+            {
+                FlywheelEnergy = stallEnergy * 1.2f;
+            }
+
+            FlywheelEnergy = Math.Max(FlywheelEnergy, 0);
+        }
+
+        private void UpdateRevLimiter(float totalTime)
+        {
+            if (RPM > RevLimit)
+            {
+                _cutoffUntil = totalTime + 0.01f;
+            }
+            _cutoff = (totalTime < _cutoffUntil);
+        }
+
+        private float CalculateFrictionLoss(float deltaTime)
+        {
+            float frictionTorque = GetFrictionTorque();
+            float frictionPower = frictionTorque * AngularVelocity;
+            return frictionPower * deltaTime;
+        }
+
+        private float GetFrictionTorque()
+        {
+            return RPM switch
+            {
+                < 500 => 15f,
+                < 1000 => 14f,
+                < 2000 => 16f,
+                < 3000 => 18f,
+                < 4000 => 21f,
+                < 5000 => 25f,
+                < 6000 => 30f,
+                < 7000 => 36f,
+                _ => 44f
+            };
+        }
+
+        private float CalculateCombustionPower(float deltaTime)
+        {
+            float throttle = GetActualThrottle();
+            if (_cutoff) throttle = 0;
+            float torque = GetTorqueOutput() * throttle;
+            return torque * AngularVelocity * deltaTime;
+        }
+
+        public float GetActualThrottle()
+        {
+            if (RPM < IdleRPM && Throttle < 0.1f)
+            {
+                float idleThrottle = (IdleRPM - RPM) / 200f;
+                return Math.Clamp(idleThrottle, 0.1f, 0.3f);
+            }
+            return Throttle;
+        }
+
+        public float GetOmega() => MathF.Sqrt(2f * FlywheelEnergy / MomentOfInertia);
+        public float GetRPM() => GetOmega() * PhysicsUtil.RAD_PER_SEC_TO_RPM;
+
+        public float GetEnergyFromRPM(float rpm)
+        {
+            float omega = rpm * PhysicsUtil.RPM_TO_RAD_PER_SEC;
+            return 0.5f * MomentOfInertia * omega * omega;
+        }
+
+        public float GetTorqueOutput() => _torqueCurve.GetTorqueAtRPM(RPM);
+    }
+
+    public class TorqueCurve
+    {
+        private List<(float RPM, float Torque)> _points = new List<(float, float)>();
+
+        public void AddPoint(float rpm, float torque) => _points.Add((rpm, torque));
+
+        public float GetTorqueAtRPM(float rpm)
+        {
+            if (rpm <= 400) return 0;
+            if (_points.Count == 0) return 0;
+
+            var orderedPoints = _points.OrderBy(p => p.RPM).ToList();
+            if (rpm <= orderedPoints.First().RPM) return orderedPoints.First().Torque;
+            if (rpm >= orderedPoints.Last().RPM) return orderedPoints.Last().Torque;
+
+            for (int i = 0; i < orderedPoints.Count - 1; i++)
+            {
+                if (rpm >= orderedPoints[i].RPM && rpm <= orderedPoints[i + 1].RPM)
+                {
+                    float t = (rpm - orderedPoints[i].RPM) / (orderedPoints[i + 1].RPM - orderedPoints[i].RPM);
+                    return PhysicsUtil.Lerp(orderedPoints[i].Torque, orderedPoints[i + 1].Torque, t);
+                }
+            }
+
+            return 0f;
+        }
+    }
+}