Update for parity with 1.18.2

Author: TechTastic

changelog.md

@@ -1,7 +1,8 @@
-Fixes
-- Removed the thorns in my side (getRoll, getPitch, getYaw)
-- Welcome to Quaternion to Euler conversions (added the following methods)
-  - getEulerAnglesXYZ
-  - getEulerAnglesYXZ
-  - getEulerAnglesZXY
-  - getEulerAnglesZYX
+# Changes
+- Removed the `getEulerAngles***` methods in favor of a `quaternion` Lua library in-game
+- Added `quaternion` Lua library as an in-game API
+- Changed the `physics_tick` event to `physics_ticks` and updated how it works
+  - `physics_ticks` now saves up previous ticks of data THEN, on game tick, send out the event with the queued physics data
+- Updated config documentation
+- Added `ship` help page in-game
+- Added new methods to both Ship and Extended Ship API that take vectors

common/src/main/kotlin/io/github/techtastic/cc_vs/apis/ExtendedShipAPI.kt

@@ -7,6 +7,7 @@ import dan200.computercraft.core.apis.IAPIEnvironment
 import io.github.techtastic.cc_vs.PlatformUtils
 import io.github.techtastic.cc_vs.ship.PhysTickEventHandler
 import io.github.techtastic.cc_vs.ship.QueuedForcesApplier
+import io.github.techtastic.cc_vs.util.CCVSUtils.toVector
 import net.minecraft.server.level.ServerLevel
 import org.joml.Quaterniond
 import org.joml.Quaterniondc
@@ -30,31 +31,69 @@ class ExtendedShipAPI(private val api: IAPIEnvironment, ship: ServerShip, level:
         this.control.applyInvariantForce(Vector3d(xForce, yForce, zForce))
     }
 
+    @LuaFunction
+    fun applyInvariantForce(force: Map<*,*>) {
+        val newVec = force.toVector()
+        applyInvariantForce(newVec.x(), newVec.y(), newVec.z())
+    }
+
     @LuaFunction
     fun applyInvariantTorque(xTorque: Double, yTorque: Double, zTorque: Double) {
         this.control.applyInvariantTorque(Vector3d(xTorque, yTorque, zTorque))
     }
 
+    @LuaFunction
+    fun applyInvariantTorque(torque: Map<*,*>) {
+        val newVec = torque.toVector()
+        applyInvariantForce(newVec.x(), newVec.y(), newVec.z())
+    }
+
     @LuaFunction
     fun applyInvariantForceToPos(xForce: Double, yForce: Double, zForce: Double, xPos: Double, yPos: Double, zPos: Double) {
         this.control.applyInvariantForceToPos(Vector3d(xForce, yForce, zForce), Vector3d(xPos, yPos, zPos))
     }
 
+    @LuaFunction
+    fun applyInvariantForceToPos(force: Map<*,*>, pos: Map<*,*>) {
+        val newForce = force.toVector()
+        val newPos = pos.toVector()
+        applyInvariantForceToPos(newForce.x(), newForce.y(), newForce.z(), newPos.x(), newPos.y(), newPos.z())
+    }
+
     @LuaFunction
     fun applyRotDependentForce(xForce: Double, yForce: Double, zForce: Double) {
         this.control.applyRotDependentForce(Vector3d(xForce, yForce, zForce))
     }
 
+    @LuaFunction
+    fun applyRotDependentForce(force: Map<*,*>) {
+        val newVec = force.toVector()
+        applyRotDependentForce(newVec.x(), newVec.y(), newVec.z())
+    }
+
     @LuaFunction
     fun applyRotDependentTorque(xTorque: Double, yTorque: Double, zTorque: Double) {
         this.control.applyRotDependentTorque(Vector3d(xTorque, yTorque, zTorque))
     }
 
+    @LuaFunction
+    fun applyRotDependentTorque(torque: Map<*,*>) {
+        val newVec = torque.toVector()
+        applyRotDependentTorque(newVec.x(), newVec.y(), newVec.z())
+    }
+
     @LuaFunction
     fun applyRotDependentForceToPos(xForce: Double, yForce: Double, zForce: Double, xPos: Double, yPos: Double, zPos: Double) {
         this.control.applyRotDependentForceToPos(Vector3d(xForce, yForce, zForce), Vector3d(xPos, yPos, zPos))
     }
 
+    @LuaFunction
+    fun applyRotDependentForceToPos(force: Map<*,*>, pos: Map<*,*>) {
+        val newForce = force.toVector()
+        val newPos = pos.toVector()
+        applyRotDependentForceToPos(newForce.x(), newForce.y(), newForce.z(), newPos.x(), newPos.y(), newPos.z())
+    }
+
     @LuaFunction
     fun setStatic(b: Boolean) {
         this.control.setStatic(b)

common/src/main/kotlin/io/github/techtastic/cc_vs/apis/ShipAPI.kt

@@ -1,16 +1,23 @@
 package io.github.techtastic.cc_vs.apis
 
+import dan200.computercraft.api.lua.IArguments
 import dan200.computercraft.api.lua.ILuaAPI
+import dan200.computercraft.api.lua.LuaException
 import dan200.computercraft.api.lua.LuaFunction
 import io.github.techtastic.cc_vs.mixin.ShipObjectWorldAccessor
+import io.github.techtastic.cc_vs.util.CCVSUtils
 import io.github.techtastic.cc_vs.util.CCVSUtils.toLua
+import io.github.techtastic.cc_vs.util.CCVSUtils.toVector
 import net.minecraft.server.level.ServerLevel
+import net.minecraft.world.phys.Vec3
 import org.joml.Vector3d
 import org.joml.Vector4d
 import org.joml.primitives.AABBi
 import org.valkyrienskies.core.api.ships.ServerShip
+import org.valkyrienskies.core.apigame.constraints.VSAttachmentConstraint
 import org.valkyrienskies.core.apigame.constraints.VSConstraintAndId
 import org.valkyrienskies.mod.common.shipObjectWorld
+import org.valkyrienskies.mod.common.util.toJOML
 import kotlin.math.asin
 import kotlin.math.atan2
 
@@ -42,7 +49,7 @@ open class ShipAPI(val ship: ServerShip, val level: ServerLevel) : ILuaAPI {
         this.ship.inertiaData.momentOfInertiaTensor.toLua()
 
     @LuaFunction
-    fun getName(): String = this.ship.slug ?: "no-name"
+    fun getSlug(): String = this.ship.slug ?: "no-name"
 
     @LuaFunction
     fun getOmega(): Map<String, Double> =
@@ -52,22 +59,6 @@ open class ShipAPI(val ship: ServerShip, val level: ServerLevel) : ILuaAPI {
     fun getQuaternion(): Map<String, Double> =
         this.ship.transform.shipToWorldRotation.toLua()
 
-    @LuaFunction
-    fun getEulerAnglesXYZ() =
-        this.ship.transform.shipToWorldRotation.getEulerAnglesXYZ(Vector3d()).toLua()
-
-    @LuaFunction
-    fun getEulerAnglesYXZ() =
-        this.ship.transform.shipToWorldRotation.getEulerAnglesYXZ(Vector3d()).toLua()
-
-    @LuaFunction
-    fun getEulerAnglesZXY() =
-        this.ship.transform.shipToWorldRotation.getEulerAnglesZXY(Vector3d()).toLua()
-
-    @LuaFunction
-    fun getEulerAnglesZYX() =
-        this.ship.transform.shipToWorldRotation.getEulerAnglesZYX(Vector3d()).toLua()
-
     @LuaFunction
     fun getScale(): Map<String, Double> =
         this.ship.transform.shipToWorldScaling.toLua()
@@ -98,11 +89,18 @@ open class ShipAPI(val ship: ServerShip, val level: ServerLevel) : ILuaAPI {
     fun transformPositionToWorld(x: Double, y: Double, z: Double): Map<String, Double> =
         this.ship.shipToWorld.transformPosition(Vector3d(x, y, z)).toLua()
 
+    @LuaFunction
+    fun transformPositionToWorld(table: Map<*,*>): Map<String, Double> {
+        val pos = table.toVector()
+
+        return transformPositionToWorld(pos.x(), pos.y(), pos.z())
+    }
+
     @LuaFunction
     fun isStatic(): Boolean = this.ship.isStatic
 
     @LuaFunction
-    fun setName(name: String) {
+    fun setSlug(name: String) {
         this.ship.slug = name
     }
 

common/src/main/kotlin/io/github/techtastic/cc_vs/ship/PhysTickEventHandler.kt

@@ -5,34 +5,38 @@ import io.github.techtastic.cc_vs.PlatformUtils
 import io.github.techtastic.cc_vs.apis.LuaPhysShip
 import org.valkyrienskies.core.api.ships.*
 import org.valkyrienskies.core.impl.game.ships.PhysShipImpl
+import java.util.concurrent.ConcurrentLinkedQueue
 
-class PhysTickEventHandler: ShipForcesInducer {
+class PhysTickEventHandler: ShipForcesInducer, ServerTickListener {
     @JsonIgnore
     private val computers = mutableListOf<Int>()
+    private val queuedData = ConcurrentLinkedQueue<LuaPhysShip>()
 
     override fun applyForces(physShip: PhysShip) {
         if (!PlatformUtils.exposePhysTick())
             return
 
-        val physShip = physShip as PhysShipImpl
-
-        this.computers.removeIf { PlatformUtils.getComputerByID(it) == null }
-
-        this.computers.forEach {
-            PlatformUtils.getComputerByID(it)?.queueEvent("physics_tick", arrayOf(LuaPhysShip(physShip)))
-        }
+        this.queuedData.add(LuaPhysShip(physShip as PhysShipImpl))
     }
 
     fun addComputer(id: Int) {
         this.computers.add(id)
     }
 
+    override fun onServerTick() {
+        this.computers.removeIf { PlatformUtils.getComputerByID(it) == null }
+        this.computers.forEach {
+            PlatformUtils.getComputerByID(it)?.queueEvent("physics_ticks", this.queuedData.toTypedArray())
+        }
+        this.queuedData.clear()
+    }
+
     companion object {
         fun getOrCreateControl(ship: ServerShip): PhysTickEventHandler {
-            var control = ship.getAttachment(PhysTickEventHandler::class.java)
+            var control = ship.getAttachment<PhysTickEventHandler>()
             if (control == null) {
                 control = PhysTickEventHandler()
-                ship.saveAttachment(PhysTickEventHandler::class.java, control)
+                ship.saveAttachment<PhysTickEventHandler>(control)
             }
 
             return control

common/src/main/kotlin/io/github/techtastic/cc_vs/util/CCVSUtils.kt

@@ -1,5 +1,6 @@
 package io.github.techtastic.cc_vs.util
 
+import dan200.computercraft.api.lua.LuaException
 import dan200.computercraft.shared.computer.core.ComputerFamily
 import dan200.computercraft.shared.computer.core.ServerComputer
 import io.github.techtastic.cc_vs.PlatformUtils
@@ -121,4 +122,11 @@ object CCVSUtils {
 
         return constraint
     }
+
+    fun Map<*, *>.toVector(): Vector3dc {
+        val posTable = this as? Map<String, Double>
+            ?: throw LuaException("Invalid Argument! Expects either a vector or a table with x, y, and z keys!")
+
+        return Vector3d(posTable["x"] ?: 0.0, posTable["y"] ?: 0.0, posTable["z"] ?: 0.0)
+    }
 }