Merge pull request #10 from NextFTC/revert-9-revert-8-main

Revert "Revert "v1 :)""

Author: zachwaffle4

.DS_Store

@@ -0,0 +1,97 @@
+package com.acmerobotics.roadrunner.actions
+
+import com.acmerobotics.dashboard.canvas.Canvas
+import com.acmerobotics.dashboard.telemetry.TelemetryPacket
+
+/**
+ * Action combinator that executes the action group [initialActions] in series. Each action is run one after the other.
+ * When an action completes, the next one is immediately run. This action completes when the last action completes.
+ */
+data class SequentialAction(
+    val initialActions: List<Action>
+) : Action {
+    var actions = initialActions.flatMap {
+        if (it is SequentialAction) it.initialActions else listOf(it)
+    }
+        private set
+
+    constructor(vararg actions: Action) : this(actions.asList())
+
+    override tailrec fun run(p: TelemetryPacket): Boolean {
+        if (actions.isEmpty()) {
+            return false
+        }
+
+        return if (actions.first().run(p)) {
+            true
+        } else {
+            actions = actions.drop(1)
+            run(p)
+        }
+    }
+
+    override fun preview(fieldOverlay: Canvas) {
+        for (a in initialActions) {
+            a.preview(fieldOverlay)
+        }
+    }
+}
+
+/**
+ * Action combinator that executes the action group [initialActions] in parallel. Each call to [run] on this action
+ * calls [run] on _every_ live child action in the order provided. Completed actions are removed from the rotation
+ * and _do not_ prevent the completion of other actions. This action completes when all of [initialActions] have.
+ */
+data class ParallelAction(
+    val initialActions: List<Action>
+) : Action {
+    var actions = initialActions.flatMap {
+        if (it is ParallelAction) it.initialActions else listOf(it)
+    }
+        private set
+
+    constructor(vararg actions: Action) : this(actions.asList())
+
+    override fun run(p: TelemetryPacket): Boolean {
+        actions = actions.filter { it.run(p) }
+        return actions.isNotEmpty()
+    }
+
+    override fun preview(fieldOverlay: Canvas) {
+        for (a in initialActions) {
+            a.preview(fieldOverlay)
+        }
+    }
+}
+
+/**
+ * Action combinator that executes the action group [initialActions] in parallel. Each call to [run] on this action
+ * calls [run] on _every_ live child action in the order provided. Once one action ends, all other actions are ended.
+ */
+class RaceAction(
+    initialActions: List<Action>
+) : Action {
+    var actions = initialActions
+        private set
+    var interrupting = false
+
+    constructor(vararg actions: Action) : this(actions.asList())
+
+    override fun run(p: TelemetryPacket): Boolean {
+        val remaining = actions.filter { it.run(p) }
+        if (interrupting) {
+            return remaining.isNotEmpty()
+        } else if (actions.size != remaining.size) {
+            interrupting = true
+            actions = remaining.filter { it is Interruptible }
+                .map { (it as Interruptible).onInterrupt() }
+        }
+        return true
+    }
+
+    override fun preview(fieldOverlay: Canvas) {
+        for (a in actions) {
+            a.preview(fieldOverlay)
+        }
+    }
+}

.gca/actions/ActionGroups.kt

@@ -0,0 +1,155 @@
+package com.acmerobotics.roadrunner.actions
+
+import com.acmerobotics.dashboard.canvas.Canvas
+import com.acmerobotics.dashboard.telemetry.TelemetryPacket
+import kotlin.time.ComparableTimeMark
+import kotlin.time.Duration
+import kotlin.time.Duration.Companion.nanoseconds
+import kotlin.time.Duration.Companion.seconds
+import kotlin.time.DurationUnit
+import kotlin.time.TimeSource
+import kotlin.time.TimeSource.Monotonic.markNow
+import kotlin.time.toJavaDuration
+import kotlin.time.toKotlinDuration
+
+/**
+ * Concurrent task for cooperative multitasking with some FTC dashboard hooks. Actions may have a mutable state.
+ */
+@JvmDefaultWithoutCompatibility
+fun interface Action {
+    /**
+     * Runs a single uninterruptible block. Returns true if the action should run again and false if it has completed.
+     * A telemetry packet [p] is provided to record any information on the action's progress.
+     */
+    fun run(p: TelemetryPacket): Boolean
+
+    /**
+     * Draws a preview of the action on canvas [fieldOverlay].
+     */
+    fun preview(fieldOverlay: Canvas) {}
+
+    /**
+     * The action's requirements (optional).
+     * It is up to the action queue to resolve requirements.
+     */
+    val requirements: Set<Any> get() = emptySet()
+
+    /**
+     * Returns a new action that executes this action followed by [a].
+     */
+    fun then(a: Action) = SequentialAction(this, a)
+    fun then(f: InstantFunction) = SequentialAction(this, InstantAction(f))
+    fun then(a: () -> Action) = SequentialAction(this, a())
+
+    /**
+     * Returns a new action that executes this action in parallel with [a].
+     */
+    fun with(a: Action) = ParallelAction(this, a)
+    fun with(f: InstantFunction) = ParallelAction(this, InstantAction(f))
+    fun with(a: () -> Action) = ParallelAction(this, a())
+
+    /**
+     * Returns a new action that executes this action in parallel with [a].
+     */
+    fun race(a: Action) = RaceAction(this, a)
+    fun race(f: InstantFunction) = RaceAction(this, InstantAction(f))
+    fun race(a: () -> Action) = RaceAction(this, a())
+
+    /**
+     * Returns a new action that waits [dt] seconds before executing this action.
+     */
+    fun delay(dt: Double) = SleepAction(dt).then(this)
+
+    /**
+     * Returns an interruptible copy of this action, with [onInterruption] occurring on interrupt.
+     */
+    fun interruptible(onInterruption: Action) = object : Interruptible {
+        override fun onInterrupt(): Action = onInterruption
+
+        override fun run(p: TelemetryPacket): Boolean = this@Action.run(p)
+
+        override fun preview(fieldOverlay: Canvas) = this@Action.preview(fieldOverlay)
+    }
+    fun interruptible(onInterruption: InstantFunction) = interruptible(InstantAction(onInterruption))
+    fun interruptible(onInterruption: () -> Action) = interruptible(onInterruption())
+}
+
+open class ActionEx @JvmOverloads constructor(
+    private val initBlock: (TelemetryPacket) -> Unit = { },
+    private val loopBlock: (TelemetryPacket) -> Boolean = { false },
+    private val endBlock: (TelemetryPacket) -> Unit = { }
+) : Action {
+
+    open fun init(packet: TelemetryPacket) = initBlock(packet)
+    open fun loop(packet: TelemetryPacket) = loopBlock(packet)
+    open fun end(packet: TelemetryPacket) = endBlock(packet)
+
+    private val sequential = SequentialAction(
+        { init(it).let { false } },
+        { loop(it) },
+        { end(it).let { false } }
+    )
+
+    final override fun run(packet: TelemetryPacket) = sequential.run(packet)
+
+    fun withInit(initBlock: (TelemetryPacket) -> Unit) = ActionEx(initBlock, loopBlock, endBlock)
+    fun withLoop(loopBlock: (TelemetryPacket) -> Boolean) = ActionEx(initBlock, loopBlock, endBlock)
+    fun withEnd(endBlock: (TelemetryPacket) -> Unit) = ActionEx(initBlock, loopBlock, endBlock)
+}
+
+/**
+ * Utility object for action-related functionality.
+ */
+object Actions {
+    /**
+     * Returns the current time in seconds.
+     */
+    @JvmStatic fun now() = System.nanoTime().nanoseconds.toDouble(DurationUnit.SECONDS)
+}
+
+/**
+ * Primitive sleep action that stalls for [dt].
+ */
+data class SleepAction(val dt: Duration) : ActionEx() {
+    constructor(dt: java.time.Duration) : this(dt.toKotlinDuration())
+    constructor(dt: Double) : this(dt.seconds)
+
+    private lateinit var start: ComparableTimeMark
+
+    override fun init(packet: TelemetryPacket) {
+        start = markNow()
+    }
+
+    override fun loop(packet: TelemetryPacket) = (start.elapsedNow() - dt).isPositive()
+}
+fun interface InstantFunction {
+    fun run()
+}
+
+/**
+ * Instant action that executes [f] immediately.
+ */
+class InstantAction(val f: InstantFunction) : Action {
+    override fun run(p: TelemetryPacket): Boolean {
+        f.run()
+        return false
+    }
+}
+
+/**
+ * Null action that does nothing.
+ */
+class NullAction : Action {
+    override fun run(p: TelemetryPacket) = false
+}
+
+/**
+ * An action that can be interrupted, providing a specific action to execute upon interruption.
+ */
+interface Interruptible : Action {
+
+    /**
+     * Returns the action to execute upon interruption.
+     */
+    fun onInterrupt(): Action
+}

.gca/actions/Actions.kt

@@ -0,0 +1,114 @@
+@file:JvmName("Actions")
+
+package com.acmerobotics.roadrunner.ftc
+
+import android.content.Context
+import com.acmerobotics.dashboard.FtcDashboard
+import com.acmerobotics.dashboard.canvas.Canvas
+import com.acmerobotics.dashboard.telemetry.TelemetryPacket
+import com.acmerobotics.roadrunner.actions.Action
+import com.acmerobotics.roadrunner.actions.Interruptible
+import com.qualcomm.ftccommon.FtcEventLoop
+import com.qualcomm.ftccommon.FtcRobotControllerSettingsActivity
+import com.qualcomm.robotcore.eventloop.opmode.OpMode
+import com.qualcomm.robotcore.eventloop.opmode.OpModeManagerNotifier
+import org.firstinspires.ftc.ftccommon.external.OnCreateEventLoop
+
+/**
+ * Run [a] to completion in a blocking loop.
+ */
+fun runBlocking(a: Action) {
+    val dash = FtcDashboard.getInstance()
+    val c = Canvas()
+    a.preview(c)
+
+    var b = true
+    while (b && !Thread.currentThread().isInterrupted) {
+        val p = TelemetryPacket()
+        p.fieldOverlay().operations.addAll(c.operations)
+
+        b = a.run(p)
+
+        dash.sendTelemetryPacket(p)
+    }
+}
+
+/**
+ * Singleton object responsible for managing and updating a queue of concurrent asynchronous tasks (actions).
+ * Provides methods to enqueue actions and process the queue during the robot's main loop.
+ *
+ * Implements `OpModeManagerNotifier.Notifications` to manage the actions' lifecycle across different OpMode stages.
+ */
+object ActionRunner : OpModeManagerNotifier.Notifications {
+    private val dash = lazy { FtcDashboard.getInstance() }
+    private val _actions = ArrayDeque<Action>()
+
+    /**
+     * The actions currently being run.
+     */
+    @JvmStatic
+    @get:JvmName("actions")
+    val actions: List<Action>
+        get() = _actions
+
+    /**
+     * Adds [action] to the run queue.
+     */
+    @JvmStatic
+    fun run(action: Action) {
+        val used = _actions.filter { it.requirements.any { req -> req in action.requirements} }
+        val triggerred = used.mapNotNull { when (it) {
+            is Interruptible -> it.onInterrupt()
+            else -> null
+        } }
+        _actions.removeAll(used)
+        _actions.addAll(triggerred)
+        _actions.addLast(action)
+    }
+
+    /**
+     * Adds all actions in [actions] to the run queue.
+     */
+    @JvmStatic
+    fun run(actions: Collection<Action>) {
+        actions.forEach(::run)
+    }
+
+    /**
+     * Adds all actions in [actions] to the run queue.
+     */
+    @JvmStatic
+    fun run(vararg actions: Action) {
+        actions.forEach(::run)
+    }
+
+    /**
+     * Updates the run queue.
+     * MUST be called at the end of every loop.
+     */
+    @JvmStatic
+    fun update() {
+        val p = TelemetryPacket()
+        _actions.retainAll {
+            it.run(p)
+        }
+        dash.value.sendTelemetryPacket(p)
+    }
+
+    @OnCreateEventLoop
+    @JvmStatic
+    fun register(context: Context, eventLoop: FtcEventLoop) {
+        eventLoop.opModeManager.registerListener(this)
+    }
+
+    override fun onOpModePreInit(p0: OpMode?) {
+        require(dash.isInitialized())
+        require(_actions.isEmpty())
+    }
+
+    override fun onOpModePreStart(p0: OpMode?) {}
+
+    override fun onOpModePostStop(p0: OpMode?) {
+        _actions.clear()
+    }
+}