wip flavor table

Author: kichithewolf

SerialPrograms/Source/PokemonLZA/Options/PokemonLZA_DonutBerriesOption.cpp

@@ -12,6 +12,39 @@ namespace PokemonAutomation{
 namespace NintendoSwitch{
 namespace PokemonLZA{
 
+const EnumDropdownDatabase<Flavor_Powers>& flavor_power_enum_database(){
+    static EnumDropdownDatabase<Flavor_Powers> database{
+        {Flavor_Powers::alpha,            "alpha",             "Alpha"},
+        {Flavor_Powers::humungo,           "humungo",            "Humungo"},
+        {Flavor_Powers::teensy,           "teensy",            "Teensy"},
+        {Flavor_Powers::sparkling,           "sparkling",            "Sparkling"},
+        {Flavor_Powers::item,           "item",            "Item"},
+    };
+    return database;
+}
+const EnumDropdownDatabase<Power_Pokemon_Types>& pokemon_power_enum_database(){
+    static EnumDropdownDatabase<Power_Pokemon_Types> database{
+        {Power_Pokemon_Types::all,           "all",            "All Types"},
+        {Power_Pokemon_Types::fire,           "fire",            "Fire"},
+    };
+    return database;
+}
+const EnumDropdownDatabase<Power_Item_Types>& item_power_enum_database(){
+    static EnumDropdownDatabase<Power_Item_Types> database{
+        {Power_Item_Types::berries,            "berries",             "Berry"},
+        {Power_Item_Types::candies,           "candies",            "Candy"},
+    };
+    return database;
+}
+const EnumDropdownDatabase<Power_Level>& power_level_enum_database(){
+    static EnumDropdownDatabase<Power_Level> database{
+        {Power_Level::one,      "one",      "Lv.1"},
+        {Power_Level::two,      "two",      "Lv.2"},
+        {Power_Level::three,    "three",    "Lv.3"},
+    };
+    return database;
+}
+
 StringSelectDatabase make_donut_berries_database(){
     StringSelectDatabase ret;
     for (const auto& slug : DONUT_BERRIES_SLUGS()){
@@ -77,6 +110,81 @@ std::vector<std::unique_ptr<EditableTableRow>> DonutBerriesTable::make_defaults(
 
 
 
+
+FlavorPowerTableRow::~FlavorPowerTableRow(){
+    power.remove_listener(*this);
+}
+FlavorPowerTableRow::FlavorPowerTableRow(EditableTableOption& parent_table)
+    : EditableTableRow(parent_table)
+    , power(flavor_power_enum_database(), LockMode::LOCK_WHILE_RUNNING, Flavor_Powers::alpha)
+    , type_pokemon(pokemon_power_enum_database(), LockMode::LOCK_WHILE_RUNNING, Power_Pokemon_Types::all)
+    , type_item(item_power_enum_database(), LockMode::LOCK_WHILE_RUNNING, Power_Item_Types::berries)
+    , level(power_level_enum_database(), LockMode::LOCK_WHILE_RUNNING, Power_Level::three)
+{
+    PA_ADD_OPTION(power);
+    PA_ADD_OPTION(type_pokemon);
+    PA_ADD_OPTION(type_item);
+    PA_ADD_OPTION(level);
+
+    FlavorPowerTableRow::on_config_value_changed(this);
+    power.add_listener(*this);
+}
+std::unique_ptr<EditableTableRow> FlavorPowerTableRow::clone() const{
+    std::unique_ptr<FlavorPowerTableRow> ret(new FlavorPowerTableRow(parent()));
+    ret->power.set(power);
+    ret->type_pokemon.set(type_pokemon);
+    ret->type_item.set(type_item);
+    ret->level.set(level);
+    return ret;
+}
+void FlavorPowerTableRow::on_config_value_changed(void* object){
+    Flavor_Powers power = this->power;
+
+    type_item.set_visibility(
+        power == Flavor_Powers::item
+        ? ConfigOptionState::ENABLED
+        : ConfigOptionState::HIDDEN
+    );
+
+    bool req_poke_types =
+        power == Flavor_Powers::sparkling ||
+        power == Flavor_Powers::catching ||
+        power == Flavor_Powers::move ||
+        power == Flavor_Powers::resistance;
+
+    type_pokemon.set_visibility(
+        req_poke_types
+        ? ConfigOptionState::ENABLED
+        : ConfigOptionState::HIDDEN
+    );
+}
+
+FlavorPowerTable::FlavorPowerTable()
+    : EditableTableOption_t<FlavorPowerTableRow>(
+        "<b>Flavor Powers Table:</b><br>"
+        "Add all desired flavor powers to this table. "
+        "The program will check the powers of any baked donut and compare them against the selected items in the table. "
+        "Be sure to set Number of Powers to Match above.",
+        LockMode::LOCK_WHILE_RUNNING,
+        make_defaults()
+    )
+{}
+std::vector<std::string> FlavorPowerTable::make_header() const{
+    return {
+        "Flavor Power     ",
+        "Pokemon Type     ",
+        "Item Type      ",
+        "Level    ",
+    };
+}
+std::vector<std::unique_ptr<EditableTableRow>> FlavorPowerTable::make_defaults(){
+    std::vector<std::unique_ptr<EditableTableRow>> ret;
+    ret.emplace_back(new FlavorPowerTableRow(*this));
+    return ret;
+}
+
+
+
 }
 }
 }

SerialPrograms/Source/PokemonLZA/Options/PokemonLZA_DonutBerriesOption.h

@@ -9,12 +9,72 @@
 
 #include "CommonTools/Options/StringSelectOption.h"
 #include "Common/Cpp/Options/EditableTableOption.h"
+#include "Common/Cpp/Options/EnumDropdownOption.h"
+#include "Common/Cpp/Options/SimpleIntegerOption.h"
 
 namespace PokemonAutomation{
 namespace NintendoSwitch{
 namespace PokemonLZA{
 
+enum class Flavor_Powers {
+    alpha,
+    humungo,
+    teensy,
+    sparkling,
+    atk,
+    spatk,
+    move,
+    speed,
+    bighaul,
+    item,
+    mega,
+    def,
+    spdef,
+    resistance,
+    encounter,
+    catching,
+};
+
+enum class Power_Pokemon_Types {
+    any, //Accept any of the below options
+    all, //Accept only the All type (ex. Sparkling Power: All Types (Lv. 3)) Applies to catching and sparkling, but not move or resist
+    normal,
+    fire,
+    water,
+    electric,
+    grass,
+    ice,
+    fighting,
+    poison,
+    ground,
+    flying,
+    psychic,
+    bug,
+    rock,
+    ghost,
+    dragon,
+    dark,
+    steel,
+    fairy,
+};
+
+enum class Power_Item_Types {
+    berries,
+    candies,
+    treasure,
+    pokeballs,
+    special,
+    coins,
+};
+
+enum class Power_Level{
+    one,
+    two,
+    three,
+};
+
 
+//Berry + Hyperspace Berry selection
 class DonutBerriesTableCell : public StringSelectCell{
 public:
     DonutBerriesTableCell(const std::string& default_slug);
@@ -41,6 +101,35 @@ class DonutBerriesTable : public EditableTableOption_t<DonutBerriesTableRow>{
 
 
 
+//Donut Flavor Power selection
+class FlavorPowerTableRow : public EditableTableRow, public ConfigOption::Listener{
+public:
+    ~FlavorPowerTableRow();
+    FlavorPowerTableRow(EditableTableOption& parent_table);
+    virtual std::unique_ptr<EditableTableRow> clone() const override;
+
+private:
+    virtual void on_config_value_changed(void* object) override;
+
+private:
+    EnumDropdownCell<Flavor_Powers> power;
+    EnumDropdownCell<Power_Pokemon_Types> type_pokemon;
+    EnumDropdownCell<Power_Item_Types> type_item;
+    EnumDropdownCell<Power_Level> level;
+};
+
+
+class FlavorPowerTable : public EditableTableOption_t<FlavorPowerTableRow>{
+public:
+    FlavorPowerTable();
+
+    virtual std::vector<std::string> make_header() const;
+
+    std::vector<std::unique_ptr<EditableTableRow>> make_defaults();
+
+};
+
+
 }
 }
 }

SerialPrograms/Source/PokemonLZA/Programs/TestPrograms/PokemonLZA_DonutOptionsTest.cpp

@@ -36,11 +36,18 @@ DonutOptionsTest_Descriptor::DonutOptionsTest_Descriptor()
 DonutOptionsTest::DonutOptionsTest()
     : LANGUAGE(
         "<b>Game Language:</b>",
-        PokemonSwSh::IV_READER().languages(), //TODO: replace?
+        PokemonSwSh::IV_READER().languages(), //TODO: replace later or something
         LockMode::LOCK_WHILE_RUNNING,
         true
     )
     , BERRIES("<b>Berries:</b><br>The berries used to make the donut. Minimum 3 berries, maximum 8 berries.")
+    , NUM_POWER_REQUIRED(
+        "<b>Number of Powers to Match:</b><br>How many of a dount's powers must be in the the table below. Minimum 1, maximum 3. "
+        "<br>Ex. For a target dount of Big Haul Lv.3, Berry Lv.3, and any or none for the 3rd power, set the number as 2."
+        "<br>Then, in the flavor powers table, make sure to add Big Haul Lv.3 and Berry Lv. 3.",
+        LockMode::LOCK_WHILE_RUNNING,
+        1, 1, 3
+        )
     , NUM_DONUTS(
         "<b>Number of Donuts:</b><br>The number of donuts to make.",
         LockMode::LOCK_WHILE_RUNNING,
@@ -56,6 +63,8 @@ DonutOptionsTest::DonutOptionsTest()
 {
     PA_ADD_OPTION(LANGUAGE);
     PA_ADD_OPTION(BERRIES);
+    PA_ADD_OPTION(NUM_POWER_REQUIRED);
+    PA_ADD_OPTION(FLAVOR_POWERS);
     PA_ADD_OPTION(NUM_DONUTS);
     PA_ADD_OPTION(GO_HOME_WHEN_DONE);
     PA_ADD_OPTION(NOTIFICATIONS);
@@ -82,6 +91,10 @@ void DonutOptionsTest::program(SingleSwitchProgramEnvironment& env, ProControlle
     env.log("Number of berries validated.", COLOR_BLACK);
 
 
+    //Validate flavor power table
+    //(not all powers can have all types)
+
+
     GO_HOME_WHEN_DONE.run_end_of_program(context);
     send_program_finished_notification(env, NOTIFICATION_PROGRAM_FINISH);
 }

SerialPrograms/Source/PokemonLZA/Programs/TestPrograms/PokemonLZA_DonutOptionsTest.h

@@ -12,6 +12,7 @@
 #include "NintendoSwitch/Options/NintendoSwitch_GoHomeWhenDoneOption.h"
 #include "Common/Cpp/Options/SimpleIntegerOption.h"
 #include "CommonTools/Options/LanguageOCROption.h"
+#include "Common/Cpp/Options/EnumDropdownOption.h"
 #include "PokemonLZA/Options/PokemonLZA_DonutBerriesOption.h"
 
 namespace PokemonAutomation{
@@ -32,6 +33,11 @@ class DonutOptionsTest : public SingleSwitchProgramInstance{
 private:
     OCR::LanguageOCROption LANGUAGE;
     DonutBerriesTable BERRIES;
+
+    SimpleIntegerOption<uint8_t> NUM_POWER_REQUIRED;
+
+    FlavorPowerTable FLAVOR_POWERS;
+
     SimpleIntegerOption<uint8_t> NUM_DONUTS;
 
     GoHomeWhenDoneOption GO_HOME_WHEN_DONE;