Sloth

ftc {
    dairy {
        implementation(Sloth)
        // Optional: Sloth-compatible FTC Dashboard
        implementation(slothboard)
        // Optional: Sloth-compatible Panels
        implementation(ftControl.fullpanels)
    }
}

plugins {
    id("dev.frozenmilk.teamcode") version "11.0.0-1.1.0"
    id("dev.frozenmilk.sinister.sloth.load") version "0.2.4"
}

repositories {
    maven {
        url = "https://repo.dairy.foundation/releases"
    }
    maven {
        url = "https://repo.dairy.foundation/snapshots"
    }
}

repositories {
    maven {
        url = uri("https://repo.dairy.foundation/releases")
    }
    maven {
        url = uri("https://repo.dairy.foundation/snapshots")
    }
}

dependencies {
    implementation("dev.frozenmilk.sinister:Sloth:0.2.4")
}

dependencies {
    // This includes Sloth
    implementation("dev.frozenmilk.dairy:Core:2.2.4")
}

@TeleOp(name = "Quick Test")
public class QuickTest extends LinearOpMode {
    @Override
    public void runOpMode() {
        DcMotor motor = hardwareMap.get(DcMotor.class, "motor");
        
        waitForStart();
        
        while (opModeIsActive()) {
            // Try different values quickly
            double power = 0.5;  // Change this
            motor.setPower(power);
            
            telemetry.addData("Power", power);
            telemetry.update();
        }
        // Stop OpMode → Changes deployed automatically
    }
}

@TeleOp(name = "Quick Test")
class QuickTest : LinearOpMode() {
    override fun runOpMode() {
        val motor = hardwareMap.get(DcMotor::class.java, "motor")
        
        waitForStart()
        
        while (opModeIsActive()) {
            // Try different values quickly
            val power = 0.5  // Change this
            motor.power = power
            
            telemetry.addData("Power", power)
            telemetry.update()
        }
        // Stop OpMode → Changes deployed automatically
    }
}

import dev.frozenmilk.sinister.targeting.Pinned;

// This class WON'T be hot reloaded
@Pinned
public class CriticalHardwareConfig {
    // Hardware initialization that shouldn't change mid-session
    public static final double WHEEL_DIAMETER = 4.0;
    public static final double GEAR_RATIO = 1.5;
}

// Subclasses of @Pinned are also pinned
public class ExtendedConfig extends CriticalHardwareConfig {
    // This also won't hot reload
}

import dev.frozenmilk.sinister.targeting.Pinned

// This class WON'T be hot reloaded
@Pinned
class CriticalHardwareConfig {
    companion object {
        // Hardware initialization that shouldn't change mid-session
        const val WHEEL_DIAMETER = 4.0
        const val GEAR_RATIO = 1.5
    }
}

// Subclasses of @Pinned are also pinned
class ExtendedConfig : CriticalHardwareConfig() {
    // This also won't hot reload
}

@TeleOp(name = "PID Tuner")
public class PIDTuner extends LinearOpMode {
    @Override
    public void runOpMode() {
        DcMotorEx motor = hardwareMap.get(DcMotorEx.class, "arm");
        
        // Tune these quickly with Sloth
        double kP = 0.01;
        double kI = 0.0;
        double kD = 0.0;
        
        PIDController controller = new PIDController(kP, kI, kD);
        
        waitForStart();
        
        while (opModeIsActive()) {
            double current = motor.getCurrentPosition();
            double target = 1000;
            
            double power = controller.calculate(current, target);
            motor.setPower(power);
            
            telemetry.addData("Position", current);
            telemetry.addData("Target", target);
            telemetry.addData("Power", power);
            telemetry.update();
        }
    }
}

// Change kP, kI, kD values → deploySloth → test immediately!

@TeleOp(name = "PID Tuner")
class PIDTuner : LinearOpMode() {
    override fun runOpMode() {
        val motor = hardwareMap.get(DcMotorEx::class.java, "arm")
        
        // Tune these quickly with Sloth
        val kP = 0.01
        val kI = 0.0
        val kD = 0.0
        
        val controller = PIDController(kP, kI, kD)
        
        waitForStart()
        
        while (opModeIsActive()) {
            val current = motor.currentPosition.toDouble()
            val target = 1000.0
            
            val power = controller.calculate(current, target)
            motor.power = power
            
            telemetry.addData("Position", current)
            telemetry.addData("Target", target)
            telemetry.addData("Power", power)
            telemetry.update()
        }
    }
}

// Change kP, kI, kD values → deploySloth → test immediately!

@Autonomous(name = "Motion Debug")
public class MotionDebug extends LinearOpMode {
    @Override
    public void runOpMode() {
        // Quickly test different profiles
        double maxVel = 50.0;  // Change these
        double maxAccel = 30.0;
        double distance = 24.0;
        
        waitForStart();
        
        // Run motion with current values
        runMotionProfile(maxVel, maxAccel, distance);
        
        // Stop → Change values → deploySloth → Run again
    }
}

@Autonomous(name = "Motion Debug")
class MotionDebug : LinearOpMode() {
    override fun runOpMode() {
        // Quickly test different profiles
        val maxVel = 50.0  // Change these
        val maxAccel = 30.0
        val distance = 24.0
        
        waitForStart()
        
        // Run motion with current values
        runMotionProfile(maxVel, maxAccel, distance)
        
        // Stop → Change values → deploySloth → Run again
    }
}

dependencies {
    // If you add this:
    implementation("com.newlibrary:lib:1.0.0")
    // You MUST do full install, not deploySloth
}

import dev.frozenmilk.sinister.SinisterFilter

// Listen for hot reloads
class MyLibraryModule : SinisterFilter {
    override fun accept(clazz: Class<*>): Boolean {
        // Return true for classes you care about
        return clazz.isAnnotationPresent(MyAnnotation::class.java)
    }
    
    override fun init(clazz: Class<*>) {
        // Called when Sloth loads/reloads this class
        println("Reloaded: ${clazz.name}")
    }
}

import dev.frozenmilk.sinister.SinisterFilter;

// Listen for hot reloads
public class MyLibraryModule implements SinisterFilter {
    @Override
    public boolean accept(Class<?> clazz) {
        // Return true for classes you care about
        return clazz.isAnnotationPresent(MyAnnotation.class);
    }
    
    @Override
    public void init(Class<?> clazz) {
        // Called when Sloth loads/reloads this class
        System.out.println("Reloaded: " + clazz.getName());
    }
}