Add propeller bearing peripheral

Note: blade angle doesn't update properly on the blade controller while its assembled. I think data isn't being synced to the client. But thats to fix later, the peripheral still works, you just can't tell from the visual.

Author: blockninja124

common/src/main/kotlin/org/valkyrienskies/clockwork/content/contraptions/propeller/PropellerBearingBlockEntity.kt

@@ -98,6 +98,12 @@ open class PropellerBearingBlockEntity(type: BlockEntityType<*>, pos: BlockPos,
     var lastPowerOne = 0
     var lastPowerTwo = 0
 
+    /**
+     * Only used by the CC peripheral so that it can set the blade angle manually
+     * without it resetting / being meddled with by redstone
+     */
+    var isLocked = false
+
     override fun newCreateData(): PropCreateData {
         return PropCreateData(worldPosition.toJOML(), blockState.getValue(BlockStateProperties.FACING).normal.toJOMLD(), angle, currentOmega, ArrayList(sailPositions), isInverted(), active, brass && blades.isEmpty(), ArrayList(blades))
     }
@@ -269,7 +275,7 @@ open class PropellerBearingBlockEntity(type: BlockEntityType<*>, pos: BlockPos,
     }
     // reminder: override this for copter bearing since their redstone controls something different
     open fun applyPowerEffect() {
-        if (!this.brass || blades.isEmpty() || (powerOne == 0 && powerTwo == 0)) return
+        if (!this.brass || blades.isEmpty() || (powerOne == 0 && powerTwo == 0) || isLocked) return
 
         val powerEffect = Mth.clamp((powerOne + powerTwo).toFloat() / 30f, -1f, 1f)
         val angleChange = 2f * powerEffect

common/src/main/kotlin/org/valkyrienskies/clockwork/integration/cc/PropellerBearingPeripheral.kt

@@ -0,0 +1,78 @@
+@file:Suppress("unused")
+
+package org.valkyrienskies.clockwork.integration.cc
+
+import dan200.computercraft.api.lua.LuaException
+import dan200.computercraft.api.lua.LuaFunction
+import dan200.computercraft.api.peripheral.IPeripheral
+import org.valkyrienskies.clockwork.ClockworkBlocks
+import org.valkyrienskies.clockwork.content.contraptions.propeller.PropellerBearingBlockEntity
+import java.util.*
+
+class PropellerBearingPeripheral(private val be: PropellerBearingBlockEntity): IPeripheral {
+
+    @LuaFunction
+    fun isBrass(): Boolean = be.blockState.block == ClockworkBlocks.BRASS_PROPELLER_BEARING
+
+    @LuaFunction
+    fun getAngle(): Float = be.getInterpolatedAngle(0.0f)
+
+    @LuaFunction
+    fun getBladeAngle(): Double = be.blades.first().angle
+
+    // Note: CC does not accept Float arguments, only Doubles.
+    // CC also doesn't understand kotlin optional parameters,
+    // so we use a Java Optional instead.
+    @LuaFunction
+    fun setBladeAngle(angle: Double, setLocked: Optional<Boolean>) {
+        if (be.blockState.block == ClockworkBlocks.BRASS_PROPELLER_BEARING) {
+            throw LuaException("setBladeAngle can only be used on a brass propeller bearing")
+        }
+
+        if (!be.running) {
+            throw LuaException("Propeller bearing is not assembled")
+        }
+
+        if ((angle < -180) || (angle > 180)) {
+            throw LuaException("Angle must be within range -180..180")
+        }
+
+        if (setLocked.isPresent) {
+            be.isLocked = setLocked.get()
+        } else {
+            be.isLocked = true
+        }
+
+        be.setNewBladeAngle(angle)
+        be.blades.clear()
+        be.getBlades()
+    }
+
+    @LuaFunction
+    fun isLocked(): Boolean = be.isLocked
+
+    @LuaFunction
+    fun setLocked(locked: Boolean) {
+        be.isLocked = locked
+    }
+
+    @LuaFunction(mainThread = true)
+    fun isRunning(): Boolean = be.running
+
+    @LuaFunction(mainThread = true)
+    fun assemble(): Boolean {
+        if (be.running) return false
+        be.assemble()
+        return true
+    }
+
+    @LuaFunction(mainThread = true)
+    fun disassemble(): Boolean {
+        if (!be.running) return false
+        be.disassemble()
+        return true
+    }
+
+    override fun equals(p0: IPeripheral?): Boolean = be.level?.getBlockState(be.blockPos)?.`is`(ClockworkBlocks.BRASS_PROPELLER_BEARING.get()) == true
+    override fun getType(): String = "cw_prop_bearing"
+}

common/src/main/kotlin/org/valkyrienskies/clockwork/integration/cc/getPeripheralCommon.kt

@@ -7,6 +7,7 @@ import net.minecraft.world.level.block.entity.BlockEntityType
 import org.valkyrienskies.clockwork.ClockworkBlockEntities
 import org.valkyrienskies.clockwork.content.contraptions.flap.FlapBearingBlockEntity
 import org.valkyrienskies.clockwork.content.contraptions.phys.bearing.PhysBearingBlockEntity
+import org.valkyrienskies.clockwork.content.contraptions.propeller.PropellerBearingBlockEntity
 import org.valkyrienskies.clockwork.content.curiosities.altmeter.AltMeterBlockEntity
 import org.valkyrienskies.clockwork.content.logistics.gas.pockets.nozzle.GasNozzleBlockEntity
 
@@ -15,7 +16,8 @@ val PERIPHERALS = mapOf<BlockEntityType<*>, (BlockEntity, Direction?) -> IPeriph
     ClockworkBlockEntities.GAS_NOZZLE.get() to {be, _ -> GasNozzlePeripheral(be as GasNozzleBlockEntity)},
     ClockworkBlockEntities.FLAP_BEARING.get() to {be, _ -> FlapBearingPeripheral(be as FlapBearingBlockEntity)},
     ClockworkBlockEntities.SMART_FLAP_BEARING.get() to {be, _ -> FlapBearingPeripheral(be as FlapBearingBlockEntity)},
-    ClockworkBlockEntities.ALT_METER.get() to {be, _ -> AltMeterPeripheral(be as AltMeterBlockEntity)}
+    ClockworkBlockEntities.ALT_METER.get() to {be, _ -> AltMeterPeripheral(be as AltMeterBlockEntity)},
+    ClockworkBlockEntities.PROPELLER_BEARING.get() to {be, _ -> PropellerBearingPeripheral(be as PropellerBearingBlockEntity)}
 )
 
 fun getPeripheralCommon(be: BlockEntity, direction: Direction?): IPeripheral? = PERIPHERALS[be.type]?.invoke(be, direction)

peripherals.md

@@ -396,6 +396,87 @@ Returns `true`, unless the bearing was already disassembled, in which case it wi
 
 ---
 
+## Propeller Bearing peripheral
+
+Peripheral type: `cw_prop_bearing`
+
+---
+
+```lua
+isBrass() -> bool
+```
+
+Whether the propeller bearing is a brass propeller bearing (false if it is a jury rigged bearing)
+
+---
+
+```lua
+getAngle() -> number
+```
+
+The current angle the bearing is at. Will be within the range `-360 .. 360`
+
+---
+
+```lua
+setBladeAngle(angle: number, locked: bool | nil)
+```
+
+Sets the blade angle of any blade controllers on the bearing. `angle` must be in the range `-180 .. 180`.
+
+If `locked` is not specified, the bearing will be "locked"
+and no longer respond to any redstone input (only computer input) until `setLocked` is used.
+If `locked` is specified as `false`, the bearing will not be locked, and will respond to redstone input, but will also reset every tick.
+
+Throws if:
+- The peripheral is not a brass propeller bearing
+- The propeller bearing is not assembled
+
+---
+
+```lua
+isLocked() -> bool
+```
+
+Whether the propeller bearing is currently locked, and will only respond to computer input (not redstone).
+
+---
+
+```lua
+setLocked(locked: bool)
+```
+
+Set the propeller bearing `locked` to true/false. If true, the propeller bearing will only respond to computer blade angle input.
+If false, the propeller bearing can accept redstone _or_ computer input, but will reset to the redstone input each tick.
+
+---
+
+```lua
+isRunning() -> bool
+```
+
+Is the propeller bearing currently assembled
+
+---
+
+```lua
+assemble() -> bool
+```
+
+Assembles the propeller bearing.
+Returns `true`, unless the bearing was already assembled, in which case it will return `false`
+
+---
+
+```lua
+disassemble() -> bool
+```
+
+Disassembles the propeller bearing.
+Returns `true`, unless the bearing was already disassembled, in which case it will return `false`
+
+---
+
 ## Altimeter peripheral
 
 Peripheral type: `cw_alt_meter`