i don't know what im doing im so confused 😢😢😢

Author: Mahmood077

.gradle/8.11/checksums/checksums.lock

@@ -0,0 +1,51 @@
+package frc.robot.subsystems.shooter;
+
+import edu.wpi.first.wpilibj2.command.Command;
+import edu.wpi.first.wpilibj2.command.RunCommand;
+import edu.wpi.first.wpilibj2.command.SubsystemBase;
+import java.util.function.DoubleSupplier;
+
+
+public class Shooter extends SubsystemBase {
+    private final ShooterIO io;
+
+    public Shooter(ShooterIO io) {
+        this.io = io;
+    }
+
+    /** 
+     * Runs the shooter in open loop using a voltage value. 
+     * The motor voltage continuously follows the supplier value
+     * while the command is active, and stops when it's interrupted.
+     */
+    public Command runVoltage(DoubleSupplier voltageSupplier) {
+        return new RunCommand(
+            () -> io.setVoltage(voltageSupplier.getAsDouble()),
+            this
+        ).finallyDo(interrupted -> io.setVoltage(0));
+    }
+
+    /** 
+     * Runs the shooter using a target RPM. 
+     * The RPM value is read continuously from the supplier, and the shooter
+     * stops when the command ends.
+     */
+    public Command runRPM(DoubleSupplier rpmSupplier) {
+        return new RunCommand(
+            () -> io.setRPM(rpmSupplier.getAsDouble()),
+            this
+        ).finallyDo(interrupted -> io.setRPM(0));
+    }
+
+    /** 
+     * Optional helper methods for direct control (not through Commands).
+     * These might be used for autonomous or testing.
+     */
+    public void setVoltage(double voltage) {
+        io.setVoltage(voltage);
+    }
+
+    public void setRPM(double rpm) {
+        io.setRPM(rpm);
+    }
+}

.gradle/8.11/checksums/sha1-checksums.bin

@@ -0,0 +1,34 @@
+package frc.robot.subsystems.shooter;
+
+/**
+ * Stores all constants used by the shooter subsystem.
+ * 
+ * This includes motor IDs, PID gains, and feedforward constants.
+ * If we ever switch ports or retune values, we only have to change them here.
+ */
+public final class ShooterConstants {
+
+    // === Motor IDs ===
+    public static final int LEFT_MOTOR_ID = 1;
+    public static final int RIGHT_MOTOR_ID = 2;
+
+    // === PID Gains ===
+    // Start with small numbers; tune later in testing.
+    public static final double kP = 0.0005;
+    public static final double kI = 0.0;
+    public static final double kD = 0.0;
+
+    // === Feedforward Gains ===
+    // These are rough guesses — tune during shooting tests.
+    public static final double kS = 0.2;   // static friction
+    public static final double kV = 0.12;  // velocity
+    public static final double kA = 0.015; // acceleration
+
+    // === Target Shooter Speeds (RPM) ===
+    public static final double CLOSE_SHOT_RPM = 2500;
+    public static final double FAR_SHOT_RPM = 4000;
+
+    private ShooterConstants() {
+        // Prevent instantiation
+    }
+}

src/main/java/frc/robot/subsystems/Shooter_SUBSYSTEM/Shooter.Java

@@ -0,0 +1,44 @@
+package frc.robot.subsystems.shooter;
+
+/**
+ * ShooterIO acts as a low-level interface for the shooter hardware.
+ * 
+ * Basically, this is what the subsystem talks to in order to control
+ * the actual shooter motors. The real motor code (Spark MAX, etc.)
+ * would go in a class that implements this interface.
+ */
+public interface ShooterIO {
+
+    /** 
+     * Sets the target shooter speed in RPM.
+     * The subsystem will call this whenever it wants the shooter to spin
+     * at a certain speed.
+     */
+    default void setRPM(double rpm) {
+        // Left empty on purpose — the real implementation will fill this in.
+    }
+
+    /**
+     * Directly sets the motor voltage. This is used for open-loop control.
+     */
+    default void setVoltage(double voltage) {
+        // Left empty — real motor code goes here later.
+    }
+
+    /**
+     * Sets the feedforward gains (Ks, Kv, Ka).
+     * These are constants used to estimate how much voltage to apply
+     * for a given speed and acceleration.
+     */
+    default void setFeedforwardGains(double Ks, double Kv, double Ka) {
+        // Nothing yet — just defines the method for the real IO class.
+    }
+
+    /**
+     * Sets the PID controller gains (Kp, Ki, Kd).
+     * These control how the shooter reacts to error in RPM.
+     */
+    default void setPIDGains(double Kp, double Ki, double Kd) {
+        // No implementation here — just a placeholder for now.
+    }
+}

src/main/java/frc/robot/subsystems/Shooter_SUBSYSTEM/ShooterConstant.Java

@@ -0,0 +1,115 @@
+package frc.robot.subsystems.shooter;
+
+import com.revrobotics.CANSparkMax;
+import com.revrobotics.CANSparkMaxLowLevel.MotorType;
+import com.revrobotics.RelativeEncoder;
+
+import edu.wpi.first.math.controller.PIDController;
+import edu.wpi.first.math.controller.SimpleMotorFeedforward;
+
+/**
+ * Real shooter IO that uses two Spark MAX motors.
+ * 
+ * Basically, this is the "hardware" version that talks to the actual robot.
+ * It handles voltages, PID tuning, and feedforward stuff.
+ */
+public class ShooterIOSparkMax implements ShooterIO {
+
+    // === Motors & encoders ===
+    private final CANSparkMax leftMotor;
+    private final CANSparkMax rightMotor;
+
+    private final RelativeEncoder leftEncoder;
+    private final RelativeEncoder rightEncoder;
+
+    // === Controllers ===
+    private final PIDController leftPID;
+    private final PIDController rightPID;
+
+    private SimpleMotorFeedforward leftFF;
+    private SimpleMotorFeedforward rightFF;
+
+    // === Constructor ===
+    public ShooterIOSparkMax(int leftID, int rightID) {
+        // create both motors
+        leftMotor = new CANSparkMax(leftID, MotorType.kBrushless);
+        rightMotor = new CANSparkMax(rightID, MotorType.kBrushless);
+
+        // reset to known state
+        leftMotor.restoreFactoryDefaults();
+        rightMotor.restoreFactoryDefaults();
+
+        // encoders for measuring speed (in RPM)
+        leftEncoder = leftMotor.getEncoder();
+        rightEncoder = rightMotor.getEncoder();
+
+        // simple starting PID and FF
+        leftPID = new PIDController(0.0005, 0, 0);
+        rightPID = new PIDController(0.0005, 0, 0);
+
+        leftFF = new SimpleMotorFeedforward(0, 0, 0);
+        rightFF = new SimpleMotorFeedforward(0, 0, 0);
+
+        // make sure motors spin same way
+        rightMotor.follow(leftMotor, true);
+    }
+
+    // === Methods from ShooterIO ===
+
+    /** Open-loop control: directly set voltage to both motors. */
+    @Override
+    public void setVoltage(double voltage) {
+        leftMotor.setVoltage(voltage);
+        rightMotor.setVoltage(voltage);
+    }
+
+    /**
+     * Closed-loop control: set target shooter speed (in RPM).
+     * The motors will try to match that speed using PID + feedforward.
+     */
+    @Override
+    public void setRPM(double rpm) {
+        double leftSpeed = leftEncoder.getVelocity();
+        double rightSpeed = rightEncoder.getVelocity();
+
+        // basic PID correction
+        double leftPIDOut = leftPID.calculate(leftSpeed, rpm);
+        double rightPIDOut = rightPID.calculate(rightSpeed, rpm);
+
+        // feedforward estimate
+        double leftFFOut = leftFF.calculate(rpm);
+        double rightFFOut = rightFF.calculate(rpm);
+
+        // combine and apply
+        double leftVoltage = leftPIDOut + leftFFOut;
+        double rightVoltage = rightPIDOut + rightFFOut;
+
+        leftMotor.setVoltage(leftVoltage);
+        rightMotor.setVoltage(rightVoltage);
+    }
+
+    /** Sets the PID gains for both motors. */
+    @Override
+    public void setPIDGains(double Kp, double Ki, double Kd) {
+        leftPID.setP(Kp);
+        leftPID.setI(Ki);
+        leftPID.setD(Kd);
+
+        rightPID.setP(Kp);
+        rightPID.setI(Ki);
+        rightPID.setD(Kd);
+    }
+
+    /** Sets feedforward constants for both sides. */
+    @Override
+    public void setFeedforwardGains(double Ks, double Kv, double Ka) {
+        leftFF = new SimpleMotorFeedforward(Ks, Kv, Ka);
+        rightFF = new SimpleMotorFeedforward(Ks, Kv, Ka);
+    }
+
+    /** Stops both motors (used for safety or when command ends). */
+    public void stopMotors() {
+        leftMotor.set(0);
+        rightMotor.set(0);
+    }
+}

src/main/java/frc/robot/subsystems/Shooter_SUBSYSTEM/ShooterIO.Java

@@ -0,0 +1,60 @@
+public package frc.robot.subsystems.shooter;
+
+/**
+ * Simulated version of the ShooterIO.
+ * 
+ * This class doesn’t control real motors — it just pretends to,
+ * so we can test code without hardware. 
+ * For now, it mostly prints or stores values so we can see what would happen.
+ */
+public class ShooterIOsim implements ShooterIO {
+
+    private double currentRPM = 0.0;
+    private double appliedVoltage = 0.0;
+
+    private double kS = 0.0;
+    private double kV = 0.0;
+    private double kA = 0.0;
+
+    private double kP = 0.0;
+    private double kI = 0.0;
+    private double kD = 0.0;
+
+    @Override
+    public void setRPM(double rpm) {
+        currentRPM = rpm;
+        System.out.println("[Sim] Shooter target RPM set to: " + rpm);
+    }
+
+    @Override
+    public void setVoltage(double voltage) {
+        appliedVoltage = voltage;
+        System.out.println("[Sim] Shooter voltage set to: " + voltage + "V");
+    }
+
+    @Override
+    public void setFeedforwardGains(double Ks, double Kv, double Ka) {
+        this.kS = Ks;
+        this.kV = Kv;
+        this.kA = Ka;
+        System.out.println("[Sim] Feedforward gains set → Ks: " + Ks + ", Kv: " + Kv + ", Ka: " + Ka);
+    }
+
+    @Override
+    public void setPIDGains(double Kp, double Ki, double Kd) {
+        this.kP = Kp;
+        this.kI = Ki;
+        this.kD = Kd;
+        System.out.println("[Sim] PID gains set → Kp: " + Kp + ", Ki: " + Ki + ", Kd: " + Kd);
+    }
+
+    /**
+     * Optional helper to view what the simulation thinks the current state is.
+     */
+    public void printSimStatus() {
+        System.out.println("[Sim Status] RPM: " + currentRPM + " | Voltage: " + appliedVoltage);
+    }
+}
+ {
+    
+}