Left AWP Left

include/auton/auton.hpp

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <string>
+
+
+namespace Pronounce {
+
+    typedef int (*AutonFunction)();
+
+    int nullAutonFunc();
+
+    class Auton {
+    private:
+        std::string name;
+        AutonFunction func;
+    public:
+        Auton();
+        Auton(std::string name, AutonFunction func);
+
+        int run();
+
+        std::string getName() {
+            return name;
+        }
+
+        void setName(std::string name) {
+            this->name = name;
+        }
+
+        AutonFunction getFunc() {
+            return func;
+        }
+
+        void setFunc(AutonFunction func) {
+            this->func = func;
+        }
+
+        ~Auton();
+    };
+} // namespace Pronounce
+
+

include/auton/autonSelector.hpp

@@ -0,0 +1,99 @@
+#pragma once
+
+#include "api.h"
+#include "auton.hpp"
+#include "driver/controller.hpp"
+#include <vector>
+
+namespace Pronounce {
+    class AutonSelector {
+    private:
+        std::vector<Auton> autons;
+        Auton defaultAuton;
+
+        Auton preAuton;
+        Auton postAuton;
+
+        Pronounce::Controller* controller;
+
+        int autonIndex = 0;
+    public:
+        AutonSelector();
+        AutonSelector(std::vector<Auton> autons, Auton defaultAuton);
+        AutonSelector(std::vector<Auton> autons, Auton defaultAuton, Pronounce::Controller* controller);
+
+        void choose();
+
+        int addAuton(Auton auton) {
+            autons.push_back(auton);
+            return autons.size() - 1;
+        }
+
+        int run() {
+            preAuton.run();
+            int result = 0;
+            if (autonIndex >= autons.size()) {
+                result = defaultAuton.run();
+            }
+            result = autons[autonIndex].run();
+            postAuton.run();
+            return result;
+        }
+
+        Auton getAuton(int index) {
+            int result = 0;
+            if (index < 0 || index >= autons.size()) {
+                return defaultAuton;
+            }
+            return autons[index];
+        }
+
+        std::vector<Auton> getAutons() {
+            return autons;
+        }
+
+        void setAutons(std::vector<Auton> autons) {
+            this->autons = autons;
+        }
+
+        Auton getDefaultAuton() {
+            return defaultAuton;
+        }
+
+        void setDefaultAuton(Auton defaultAuton) {
+            this->defaultAuton = defaultAuton;
+        }
+
+        Auton getPreAuton() {
+            return preAuton;
+        }
+
+        void setPreAuton(Auton preAuton) {
+            this->preAuton = preAuton;
+        }
+
+        Auton getPostAuton() {
+            return postAuton;
+        }
+
+        void setPostAuton(Auton postAuton) {
+            this->postAuton = postAuton;
+        }
+
+        void setController(Pronounce::Controller* controller) {
+            this->controller = controller;
+        }
+
+        int getAutonIndex() {
+            return autonIndex;
+        }
+
+        void setAutonIndex(int autonIndex) {
+            this->autonIndex = autonIndex;
+        }
+
+        ~AutonSelector();
+    };      
+}
+
+

include/defines.h

@@ -1,4 +1,4 @@
 #pragma once
 
-#define AUTON_SELECTOR_COUNT 3
+#define AUTON_SELECTOR_COUNT 2
 

include/driver/button.hpp

@@ -20,7 +20,7 @@ namespace Pronounce {
         pros::controller_digital_e_t positiveButton, negativeButton;
 
         bool singleToggle = false;
-        bool retainOnNeutral = true;
+        bool retainOnNeutral = false;
 
     public:
         Button(pros::Controller* cotroller);
@@ -62,6 +62,14 @@ namespace Pronounce {
             this->retainOnNeutral = retainOnNeutral;
         }
 
+        bool getAutonomous() {
+            return this->autonomous;
+        }
+
+        void setAutonomous(bool autonomous) {
+            this->autonomous = autonomous;
+        }
+
         ~Button();
     };
 } // namespace Pronounce

include/driver/motorButton.hpp

@@ -10,10 +10,14 @@ namespace Pronounce {
     private:
         bool goToImmediately = false;
 
+        bool autonomousButton = false;
+
         int positiveAuthority = 0;
         int neutralAuthority = 0;
         int negativeAuthority = 0;
 
+        int autonomousAuthority = 0;
+
         int min = 0;
         int max = 0;
         pros::Motor* motor;
@@ -39,6 +43,22 @@ namespace Pronounce {
             this->goToImmediately = goToImmediately;
         }
 
+        int getAutonomousAuthority() {
+            return this->autonomousAuthority;
+        }
+
+        void setAutonomousAuthority(int autonomousAuthority) {
+            this->autonomousAuthority = autonomousAuthority;
+        }
+
+        bool getAutonomousButton() {
+            return this->autonomousButton;
+        }
+
+        void setAutonomousButton(bool autonomousButton) {
+            this->autonomousButton = autonomousButton;
+        }
+
         ~MotorButton();
     };
 

include/main.h

@@ -48,7 +48,10 @@
  */
 
 #include "defines.h"
-#include "autonSelector.hpp"
+
+// Auton
+#include "auton/auton.hpp"
+#include "auton/autonSelector.hpp"
 
 // Chassis
 #include "chassis/drivetrain.hpp"

src/auton/auton.cpp

@@ -0,0 +1,24 @@
+#include "auton.hpp"
+
+namespace Pronounce {
+    int nullAutonFunc() {
+        return 0;
+    }
+
+    Auton::Auton(/* args */) {
+        this->name = "";
+        this->func = nullAutonFunc;
+    }
+
+    Auton::Auton(std::string name, AutonFunction func) {
+        this->name = name;
+        this->func = func;
+    }
+
+    int Auton::run() {
+        return func();
+    }
+
+    Auton::~Auton() {
+    }
+} // namespace Pronounce