Separated the applyForces faction into several smaller functions

millennIumAMbiguity · millennIumAMbiguity · commit b1892f126c1b · 2024-04-20T15:30:52.000+02:00
diff --git a/common/src/main/kotlin/org/valkyrienskies/eureka/ship/EurekaShipControl.kt b/common/src/main/kotlin/org/valkyrienskies/eureka/ship/EurekaShipControl.kt
@@ -7,10 +7,7 @@ import com.fasterxml.jackson.annotation.JsonProperty
 import net.minecraft.core.Direction
 import net.minecraft.network.chat.TranslatableComponent
 import net.minecraft.world.entity.player.Player
-import org.joml.AxisAngle4d
-import org.joml.Quaterniond
-import org.joml.Vector3d
-import org.joml.Vector3dc
+import org.joml.*
 import org.valkyrienskies.core.api.VSBeta
 import org.valkyrienskies.core.api.ships.PhysShip
 import org.valkyrienskies.core.api.ships.ServerShip
@@ -119,10 +116,10 @@ class EurekaShipControl : ShipForcesInducer, ServerTickListener {
         // [x] Rewrite Alignment code
         // [x] Revisit Elevation code
         // [x] Balloon limiter
-        // [ ] Add Cruise code
-        // [ ] Rotation based of shipsize
+        // [x] Add Cruise code
+        // [x] Rotation based of ship size
         // [x] Engine consumption
-        // [ ] Fix elevation sensititvity
+        // [x] Fix elevation sensitivity
 
         // region Aligning
 
@@ -155,11 +152,8 @@ class EurekaShipControl : ShipForcesInducer, ServerTickListener {
         val validPlayer = controllingPlayer != null && !anchored
 
         if (isCruising && anchored) {
-            isCruising = false;
-            if (controllingPlayer != null)
-            {
-                showCruiseStatus();
-            }
+            isCruising = false
+            showCruiseStatus()
         }
 
         stabilize(
@@ -176,22 +170,8 @@ class EurekaShipControl : ShipForcesInducer, ServerTickListener {
 
         if (validPlayer) {
             val player = controllingPlayer!!
-            val currentControlData = ControlData.create(player)
-
-            // If the player is currently controlling the ship
-            if (!wasCruisePressed && player.cruise) {
-                // the player pressed the cruise button
-                isCruising = !isCruising
-                showCruiseStatus()
-            } else if (!player.cruise &&
-                isCruising &&
-                (player.leftImpulse != 0.0f || player.sprintOn || player.upImpulse != 0.0f || player.forwardImpulse != 0.0f) &&
-                currentControlData != controlData
-            ) {
-                // The player pressed another button
-                isCruising = false
-                showCruiseStatus()
-            }
+
+            val currentControlData = getControlData(player)
 
             if (!isCruising) {
                 // only take the latest control data if the player is not cruising
@@ -208,135 +188,163 @@ class EurekaShipControl : ShipForcesInducer, ServerTickListener {
         }
 
         controlData?.let { control ->
-            // region Player controlled rotation
-            val transform = physShip.transform
-            val aabb = ship.worldAABB
-            val center = transform.positionInWorld
-            val stw = transform.shipToWorld
-            val wts = transform.worldToShip
+            applyPlayerControl(control, physShip)
+            idealUpwardVel = getPlayerUpwardVel(control, mass)
+        }
 
-            val largestDistance = run {
-                var dist = center.distance(aabb.minX(), center.y(), aabb.minZ())
-                dist = max(dist, center.distance(aabb.minX(), center.y(), aabb.maxZ()))
-                dist = max(dist, center.distance(aabb.maxX(), center.y(), aabb.minZ()))
-                dist = max(dist, center.distance(aabb.maxX(), center.y(), aabb.maxZ()))
+        // region Elevation
+        val idealUpwardForce = (idealUpwardVel.y() - vel.y() - (GRAVITY / EurekaConfig.SERVER.elevationSnappiness)) *
+                mass * EurekaConfig.SERVER.elevationSnappiness
+
+        physShip.applyInvariantForce(Vector3d(0.0,
+            min(balloonForceProvided, max(idealUpwardForce, 0.0)) +
+            // Add drag to the y-component
+            vel.y() * -mass,
+            0.0)
+        )
+        // endregion
 
-                dist
-            }.coerceIn(0.5, EurekaConfig.SERVER.maxSizeForTurnSpeedPenalty)
+        physShip.isStatic = anchored
+    }
 
-            val maxLinearAcceleration = EurekaConfig.SERVER.turnAcceleration
-            val maxLinearSpeed = EurekaConfig.SERVER.turnSpeed + extraForceAngular
+    private fun getControlData(player: SeatedControllingPlayer): ControlData {
+
+        val currentControlData = ControlData.create(player)
+
+        if (!wasCruisePressed && player.cruise) {
+            // the player pressed the cruise button
+            isCruising = !isCruising
+            showCruiseStatus()
+        } else if (!player.cruise && isCruising &&
+            (player.leftImpulse != 0.0f || player.sprintOn || player.upImpulse != 0.0f || player.forwardImpulse != 0.0f) &&
+            currentControlData != controlData
+        ) {
+            // The player pressed another button
+            isCruising = false
+            showCruiseStatus()
+        }
 
-            // acceleration = alpha * r
-            // therefore: maxAlpha = maxAcceleration / r
-            val maxOmegaY = maxLinearSpeed / largestDistance
-            val maxAlphaY = maxLinearAcceleration / largestDistance
+        return currentControlData
+    }
 
-            val isBelowMaxTurnSpeed = abs(omega.y()) < maxOmegaY
+    private fun applyPlayerControl(control: ControlData, physShip: PhysShipImpl) {
 
-            val normalizedAlphaYMultiplier =
-                if (isBelowMaxTurnSpeed && control.leftImpulse != 0.0f) control.leftImpulse.toDouble()
-                else -omega.y().coerceIn(-1.0, 1.0)
+        val ship = ship ?: return
+        val transform = physShip.transform
+        val aabb = ship.worldAABB
+        val center = transform.positionInWorld
 
-            val idealAlphaY = normalizedAlphaYMultiplier * maxAlphaY
+        // region Player controlled rotation
+        val moiTensor = physShip.inertia.momentOfInertiaTensor
+        val omega: Vector3dc = physShip.poseVel.omega
 
-            val alpha = Vector3d(0.0, idealAlphaY, 0.0)
-            val angularImpulse =
-                stw.transformDirection(moiTensor.transform(wts.transformDirection(Vector3d(alpha))))
+        val largestDistance = run {
+            var dist = center.distance(aabb.minX(), center.y(), aabb.minZ())
+            dist = max(dist, center.distance(aabb.minX(), center.y(), aabb.maxZ()))
+            dist = max(dist, center.distance(aabb.maxX(), center.y(), aabb.minZ()))
+            dist = max(dist, center.distance(aabb.maxX(), center.y(), aabb.maxZ()))
 
-            val torque = Vector3d(angularImpulse)
-            physShip.applyInvariantTorque(torque)
-            // endregion
+            dist
+        }.coerceIn(0.5, EurekaConfig.SERVER.maxSizeForTurnSpeedPenalty)
 
-            // region Player controlled banking
-            val rotationVector = control.seatInDirection.normal.toJOMLD()
+        val maxLinearAcceleration = EurekaConfig.SERVER.turnAcceleration
+        val maxLinearSpeed = EurekaConfig.SERVER.turnSpeed + extraForceAngular
 
-            physShip.poseVel.transformDirection(rotationVector)
+        // acceleration = alpha * r
+        // therefore: maxAlpha = maxAcceleration / r
+        val maxOmegaY = maxLinearSpeed / largestDistance
+        val maxAlphaY = maxLinearAcceleration / largestDistance
 
-            rotationVector.y = 0.0
+        val isBelowMaxTurnSpeed = abs(omega.y()) < maxOmegaY
 
-            rotationVector.mul(idealAlphaY * -1.5)
+        val normalizedAlphaYMultiplier =
+            if (isBelowMaxTurnSpeed && control.leftImpulse != 0.0f) control.leftImpulse.toDouble()
+            else -omega.y().coerceIn(-1.0, 1.0)
 
-            physShip.poseVel.rot.transform(
-                moiTensor.transform(
-                    physShip.poseVel.rot.transformInverse(rotationVector)
-                )
-            )
+        val idealAlphaY = normalizedAlphaYMultiplier * maxAlphaY
 
-            physShip.applyInvariantTorque(rotationVector)
-            // endregion
+        physShip.applyInvariantTorque(moiTensor.transform(Vector3d(0.0, idealAlphaY, 0.0)))
+        // endregion
+
+        physShip.applyInvariantTorque(getPlayerControlledBanking(control, physShip, moiTensor, -idealAlphaY))
 
-            // region Player controlled forward and backward thrust
-            val forwardVector = control.seatInDirection.normal.toJOMLD()
-            physShip.poseVel.rot.transform(forwardVector)
-            //forwardVector.y *= 0.1 // Reduce vertical thrust
-            forwardVector.normalize()
+        physShip.applyInvariantForce(getPlayerForwardVel(control, physShip))
+    }
 
-            val s = 1 / smoothingATanMax(
-                EurekaConfig.SERVER.linearMaxMass,
-                physShip.inertia.shipMass * EurekaConfig.SERVER.linearMassScaling + EurekaConfig.SERVER.linearBaseMass
+    private fun getPlayerControlledBanking(control: ControlData, physShip: PhysShipImpl, moiTensor: Matrix3dc, strength: Double): Vector3d {
+        val rotationVector = control.seatInDirection.normal.toJOMLD()
+        physShip.poseVel.transformDirection(rotationVector)
+        rotationVector.y = 0.0
+        rotationVector.mul(strength * 1.5)
+
+        physShip.poseVel.rot.transform(
+            moiTensor.transform(
+                physShip.poseVel.rot.transformInverse(rotationVector)
             )
+        )
 
-            val maxSpeed = EurekaConfig.SERVER.linearMaxSpeed / 15;
-            oldSpeed = max(min(oldSpeed * (1-s) + control.forwardImpulse.toDouble() * s, maxSpeed), -maxSpeed)
-            forwardVector.mul(oldSpeed)
+        return rotationVector
+    }
 
-            val playerUpDirection = physShip.poseVel.transformDirection(Vector3d(0.0, 1.0, 0.0))
-            val velOrthogonalToPlayerUp =
-                vel.sub(playerUpDirection.mul(playerUpDirection.dot(vel), Vector3d()), Vector3d())
+    // Player controlled forward and backward thrust
+    private fun getPlayerForwardVel(control: ControlData, physShip: PhysShipImpl): Vector3d {
 
-            // This is the speed that the ship is always allowed to go out, without engines
-            val baseForwardVel = Vector3d(forwardVector).mul(EurekaConfig.SERVER.baseSpeed)
-            val baseForwardForce = Vector3d(baseForwardVel).sub(velOrthogonalToPlayerUp).mul(mass * 10)
+        val mass10 = physShip.inertia.shipMass * 10
+        val vel: Vector3dc = physShip.poseVel.vel
 
-            // This is the maximum speed we want to go in any scenario (when not sprinting)
-            val idealForwardVel = Vector3d(forwardVector).mul(EurekaConfig.SERVER.maxCasualSpeed)
-            val idealForwardForce = Vector3d(idealForwardVel).sub(velOrthogonalToPlayerUp).mul(mass * 10)
+        // region Player controlled forward and backward thrust
+        val forwardVector = control.seatInDirection.normal.toJOMLD()
+        physShip.poseVel.rot.transform(forwardVector)
+        forwardVector.normalize()
 
-            val extraForceNeeded = Vector3d(idealForwardForce).sub(baseForwardForce)
-            val actualExtraForce = Vector3d(baseForwardForce)
+        val s = 1 / smoothingATanMax(
+            EurekaConfig.SERVER.linearMaxMass,
+            physShip.inertia.shipMass * EurekaConfig.SERVER.linearMassScaling + EurekaConfig.SERVER.linearBaseMass
+        )
 
-            if (extraForceLinear != 0.0) {
-                actualExtraForce.fma(min(extraForceLinear / extraForceNeeded.length(), 1.0), extraForceNeeded)
-            }
+        val maxSpeed = EurekaConfig.SERVER.linearMaxSpeed / 15
+        oldSpeed = max(min(oldSpeed * (1 - s) + control.forwardImpulse.toDouble() * s, maxSpeed), -maxSpeed)
+        forwardVector.mul(oldSpeed)
 
-            physShip.applyInvariantForce(actualExtraForce)
-            // endregion
-
-            // Player controlled elevation
-            if (control.upImpulse != 0.0f) {
-                idealUpwardVel = Vector3d(0.0, 1.0, 0.0)
-                    .mul(control.upImpulse.toDouble())
-                    .mul(
-                        if (control.upImpulse < 0.0f) {
-                            EurekaConfig.SERVER.baseImpulseDescendRate
-                        }
-                        else {
-                            EurekaConfig.SERVER.baseImpulseElevationRate +
-                            // Smoothing for how the elevation scales as you approaches the balloonElevationMaxSpeed
-                            smoothing(2.0, EurekaConfig.SERVER.balloonElevationMaxSpeed, balloonForceProvided / mass)
-                        }
-                    )
-            }
-        }
+        val playerUpDirection = physShip.poseVel.transformDirection(Vector3d(0.0, 1.0, 0.0))
+        val velOrthogonalToPlayerUp = vel.sub(playerUpDirection.mul(playerUpDirection.dot(vel)), Vector3d())
 
-        // region Elevation
-        val idealUpwardForce = Vector3d(
-            0.0,
-            idealUpwardVel.y() - vel.y() - (GRAVITY / EurekaConfig.SERVER.elevationSnappiness),
-            0.0
-        ).mul(mass * EurekaConfig.SERVER.elevationSnappiness)
-
-        val actualUpwardForce = Vector3d(0.0, min(balloonForceProvided, max(idealUpwardForce.y(), 0.0)), 0.0)
-        physShip.applyInvariantForce(actualUpwardForce)
-        // endregion
+        // This is the speed that the ship is always allowed to go out, without engines
+        val baseForwardVel = Vector3d(forwardVector).mul(EurekaConfig.SERVER.baseSpeed)
+        val forwardForce = Vector3d(baseForwardVel).sub(velOrthogonalToPlayerUp).mul(mass10)
 
-        // region Anchor
-        physShip.isStatic = anchored
-        // endregion
+        if (extraForceLinear != 0.0) {
+            // This is the maximum speed we want to go in any scenario (when not sprinting)
+            val idealForwardVel = Vector3d(forwardVector).mul(EurekaConfig.SERVER.maxCasualSpeed)
+            val idealForwardForce = Vector3d(idealForwardVel).sub(velOrthogonalToPlayerUp).mul(mass10)
+
+            val extraForceNeeded = Vector3d(idealForwardForce).sub(forwardForce)
+            forwardForce.fma(min(extraForceLinear / extraForceNeeded.length(), 1.0), extraForceNeeded)
+        }
+
+        return forwardForce
+    }
 
-        // Add drag to the y-component
-        physShip.applyInvariantForce(Vector3d(0.0, vel.y(),0.0).mul(-mass))
+    // Player controlled elevation
+    private fun getPlayerUpwardVel(control: ControlData, mass: Double): Vector3d {
+        if (control.upImpulse != 0.0f) {
+
+            val balloonForceProvided = balloons * forcePerBalloon
+
+            return Vector3d(0.0, 1.0, 0.0)
+                .mul(control.upImpulse.toDouble())
+                .mul(
+                    if (control.upImpulse < 0.0f) {
+                        EurekaConfig.SERVER.baseImpulseDescendRate
+                    }
+                    else {
+                        EurekaConfig.SERVER.baseImpulseElevationRate +
+                                // Smoothing for how the elevation scales as you approaches the balloonElevationMaxSpeed
+                                smoothing(2.0, EurekaConfig.SERVER.balloonElevationMaxSpeed, balloonForceProvided / mass)
+                    }
+                )
+        }
+        return Vector3d(0.0, 0.0, 0.0)
     }
 
     private fun showCruiseStatus() {
@@ -404,7 +412,7 @@ class EurekaShipControl : ShipForcesInducer, ServerTickListener {
         powerLinear = 0.0
 
         extraForceAngular = powerAngular
-        powerAngular = 0.0;
+        powerAngular = 0.0
 
         consumed = physConsumption * /* should be physics ticks based*/ 0.1f
         physConsumption = 0.0f
