ME:
I need a function, where i can read a serial input and write the input into an array



ChatGPT:
Sure! Below is an Arduino function that reads serial input and stores the received characters into an array. This function continuously reads from the serial buffer until it encounters a newline character (\n) or reaches the maximum buffer size.

Code Explanation
The function readSerialInput() reads characters from the serial buffer.
It stores the input in an array until a newline (\n) is received or the buffer size is exceeded.
The function ensures the string is properly terminated with a null character (\0).
You can modify MAX_INPUT_LENGTH to set the maximum input size.
Arduino Code
cpp
Kopieren
Bearbeiten
#define MAX_INPUT_LENGTH 50  // Define max length of input array

char inputBuffer[MAX_INPUT_LENGTH];  // Array to store input
int index = 0;  // Index to track position in array

void setup() {
    Serial.begin(9600);  // Initialize Serial Monitor
    Serial.println("Enter text:");
}

void loop() {
    readSerialInput();  // Call function to read serial input
}

void readSerialInput() {
    while (Serial.available()) {  // Check if data is available to read
        char receivedChar = Serial.read();  // Read one character

        if (receivedChar == '\n') {  // Stop reading on newline
            inputBuffer[index] = '\0';  // Null-terminate the string
            Serial.print("Received: ");
            Serial.println(inputBuffer);  // Print stored input
            index = 0;  // Reset index for next input
            return;
        }

        if (index < MAX_INPUT_LENGTH - 1) {  // Ensure within bounds
            inputBuffer[index] = receivedChar;  // Store character
            index++;
        }
    }
}
How It Works
User enters data in the Serial Monitor (e.g., "Hello Arduino").
Function reads each character until a newline (\n) is detected.
Stores characters in inputBuffer and ensures it doesn’t exceed MAX_INPUT_LENGTH.
Prints the received string and resets index for the next input.
Let me know if you need modifications!


-----------------------------------------------------------------------------------------------------------------------------------------------------------



Me:
chararray to string


ChatGPT:
In Arduino (C++), you can convert a character array (char[]) to a String object using the String constructor. Here's how:

Method 1: Using String Constructor
cpp
Kopieren
Bearbeiten
char inputBuffer[] = "Hello, Arduino!";
String str = String(inputBuffer);  // Convert char array to String

Serial.println(str);  // Output: Hello, Arduino!
Method 2: Using a Loop (If You Want Manual Conversion)
If you want to manually convert each character, you can append characters one by one using +=:

cpp
Kopieren
Bearbeiten
char inputBuffer[] = "Hello, Arduino!";
String str = "";

for (int i = 0; inputBuffer[i] != '\0'; i++) {
    str += inputBuffer[i];  // Append each character to String
}

Serial.println(str);
Example: Read Serial Input and Convert to String
If you're reading from serial and want to convert it to a String, use this:

cpp
Kopieren
Bearbeiten
#define MAX_INPUT_LENGTH 50

char inputBuffer[MAX_INPUT_LENGTH];
int index = 0;

void setup() {
    Serial.begin(9600);
    Serial.println("Enter text:");
}

void loop() {
    while (Serial.available()) {
        char receivedChar = Serial.read();
        
        if (receivedChar == '\n') {
            inputBuffer[index] = '\0';  // Null-terminate
            String str = String(inputBuffer);  // Convert char array to String
            Serial.print("String: ");
            Serial.println(str);  // Print String output
            
            index = 0;  // Reset for next input
            return;
        }

        if (index < MAX_INPUT_LENGTH - 1) {
            inputBuffer[index] = receivedChar;
            index++;
        }
    }
}
This will read serial input, store it in char[], and then convert it to String.

Let me know if you need more help! 😊

------------------------------------------------------------------------------------------------------------------------

Me:
okay this wont work for me. I need a fuction!! If this function is called, a string with the length of 25 should be read over serial and then stored as a single string




ChatGPT:
Got it! Below is a function that reads exactly 25 characters from the serial input, stores them in a char array, and converts them into a String.

Arduino Function: readSerialString()
cpp
Kopieren
Bearbeiten
#define STRING_LENGTH 25  // Define the required string length

char receivedString[STRING_LENGTH + 1];  // Array to store input (+1 for null termination)

String readSerialString() {
    int index = 0;

    while (index < STRING_LENGTH) {
        if (Serial.available()) {  // Check if data is available
            char receivedChar = Serial.read();  // Read a character

            receivedString[index] = receivedChar;  // Store in array
            index++;
        }
    }

    receivedString[STRING_LENGTH] = '\0';  // Null-terminate the char array
    return String(receivedString);  // Convert to String and return
}

void setup() {
    Serial.begin(9600);
    Serial.println("Send exactly 25 characters:");
}

void loop() {
    if (Serial.available() >= STRING_LENGTH) {  // Ensure 25 characters are available
        String result = readSerialString();  // Call function to read input
        Serial.print("Received String: ");
        Serial.println(result);
    }
}
How It Works
Reads exactly 25 characters from the serial input.
Stores characters in a char array.
Null-terminates the array (\0) to make it a valid C-string.
Converts it to a String object and returns it.
Ensures only full 25-character inputs are processed.
Example Input & Output
Input (Sent via Serial Monitor)
Kopieren
Bearbeiten
1234567890123456789012345
Output (On Serial Monitor)
arduino
Kopieren
Bearbeiten
Received String: 1234567890123456789012345
Important Notes
The function will only proceed when 25 characters are available.
No newlines (\n) are required; it strictly reads 25 bytes.
If fewer than 25 characters are available, it will wait until enough data is received.
Let me know if this needs adjustments!

--------------------------------------------------------------------------------------------------

Me:


void getDungeon(){
  int index = 0;

  while (index < STRING_LENGTH) {
    if (Serial.available()) {  // Check if data is available
      char receivedChar = Serial.read();  // Read a character
      receivedString[index] = receivedChar;  // Store in array
      index++;
    }
  }

  receivedString[STRING_LENGTH] = '\0';  // Null-terminate the char array

  int newDungeonCount = dungeonCount + 1;
  char *dungeonsNew[newDungeonCount] = {};
  
  for(int i = 0; i < newDungeonCount; i++){
    dungeonsNew[i] = dungeons[i];
  }

  dungeonsNew[newDungeonCount-1] = receivedString;
  dungeonCount = newDungeonCount;
  dungeons = dungeonsNew;
}




ChatGPT:
There are several issues with your getDungeon() function, and it could lead to memory issues or undefined behavior. Here are the problems and how to fix them:

Issues:
Array Out-of-Bounds Issue:

cpp
Kopieren
Bearbeiten
receivedString[STRING_LENGTH] = '\0';  // Null-terminate the char array
The array receivedString has a size of STRING_LENGTH, but you are assigning '\0' at STRING_LENGTH, which is out of bounds.
Instead, use receivedString[index] = '\0';, ensuring that index does not exceed STRING_LENGTH - 1.
Uninitialized Pointers in dungeonsNew:

cpp
Kopieren
Bearbeiten
char *dungeonsNew[newDungeonCount] = {};
This is not valid in standard C++. Variable-length arrays (VLAs) are not part of standard C++, though they exist in some compilers as an extension.
You need to allocate memory dynamically using new or malloc().
Shallow Copy Issue (dungeonsNew[newDungeonCount-1] = receivedString;):

receivedString is a local variable. Storing a pointer to it in dungeonsNew means when getDungeon() returns, the memory will be overwritten in the next call.
Instead, dynamically allocate memory for receivedString before storing it.
Memory Leak (dungeons = dungeonsNew;):

The original dungeons array is lost without being freed, leading to a memory leak.
Properly manage memory by deleting/freeing old allocations before replacing the pointer.
Fixed Code:
cpp
Kopieren
Bearbeiten
void getDungeon() {
  int index = 0;

  // Read the incoming string
  while (index < STRING_LENGTH - 1) {  // Leave space for null terminator
    if (Serial.available()) {
      char receivedChar = Serial.read();
      receivedString[index] = receivedChar;
      index++;
    }
  }
  receivedString[index] = '\0';  // Null-terminate

  // Allocate memory for the new dungeon string
  char *newDungeon = new char[strlen(receivedString) + 1];
  strcpy(newDungeon, receivedString); // Copy the received string

  // Allocate new array for dungeons
  char **dungeonsNew = new char*[dungeonCount + 1];

  // Copy existing dungeons to new array
  for (int i = 0; i < dungeonCount; i++) {
    dungeonsNew[i] = dungeons[i];  // Copy pointers
  }

  // Add the new dungeon to the list
  dungeonsNew[dungeonCount] = newDungeon;

  // Free the old array (not the strings, just the array pointer)
  delete[] dungeons;

  // Update dungeon list and count
  dungeons = dungeonsNew;
  dungeonCount++;
}
Improvements:
Fixed Memory Leak: Properly allocate and deallocate memory.
Prevents Buffer Overflow: Ensures receivedString is null-terminated correctly.
Avoids Shallow Copying: Dynamically allocates memory for new strings.
Uses new to Manage Dynamic Memory: Ensures safe reallocation of dungeons.
Additional Considerations:
If dungeons is modified dynamically often, consider using std::vector<std::string> (C++) instead of raw pointers.
Remember to free allocated memory when no longer needed by looping through dungeons and calling delete[] for each element.
Would you like a version using std::vector for better safety?



--------------------------------------------------------------------------------------------------------------



Me:
can you change all char arrays to String arrays


ChatGPT:
Sure! Using String (Arduino's String class) instead of char arrays simplifies memory management and avoids manual allocation. Here's your improved function using String arrays:

Updated Code with String
cpp
Kopieren
Bearbeiten
void getDungeon() {
  String receivedString = "";  // Store received characters
  
  while (receivedString.length() < STRING_LENGTH - 1) { // Leave space for safety
    if (Serial.available()) {
      char receivedChar = Serial.read();
      receivedString += receivedChar;  // Append character to String
    }
  }

  // Add the received string to the dungeons list
  dungeonCount++;
  String dungeonsNew[dungeonCount]; // Temporary array to store dungeons

  // Copy old dungeons to the new array
  for (int i = 0; i < dungeonCount - 1; i++) {
    dungeonsNew[i] = dungeons[i];
  }

  // Add the new dungeon to the last position
  dungeonsNew[dungeonCount - 1] = receivedString;

  // Update the global dungeon list
  dungeons = dungeonsNew;
}
Improvements:
✅ No need for manual memory allocation (no new or delete[])
✅ Safer memory handling (avoids dangling pointers and memory leaks)
✅ Easier string operations (no strcpy, strlen, etc.)
✅ More readable and maintainable code

Important Notes:
Ensure dungeons is declared as String* dungeons; at the global level.
If dungeons is dynamically allocated, you'll need to replace the static array with dynamic reallocation (String* instead of String[]).
If frequent additions are needed, consider using std::vector<String> instead.
Would you like a std::vector<String> version for even better flexibility? 🚀


-----------------------------------------------------------------------------------------------




Du:
String* dungeons[] = {"1111110001101011000111111","1011110100101011000111111"};
ChatGPT:
Your declaration:

cpp
Kopieren
Bearbeiten
String* dungeons[] = {"1111110001101011000111111","1011110100101011000111111"};
is incorrect because String* dungeons[] suggests an array of String* pointers, but you are initializing it with String objects.

Correct Declaration
If you want a dynamically resizable array, declare dungeons as a pointer to String (String* dungeons;), and dynamically allocate memory as needed.

Fixed Code with Dynamic Allocation
cpp
Kopieren
Bearbeiten
String* dungeons = nullptr;  // Pointer to dynamically allocated array
int dungeonCount = 0;        // Number of dungeons

void getDungeon() {
  String receivedString = "";  // Store received characters
  
  while (receivedString.length() < STRING_LENGTH - 1) { // Leave space for safety
    if (Serial.available()) {
      char receivedChar = Serial.read();
      receivedString += receivedChar;  // Append character to String
    }
  }

  // Allocate new array with increased size
  String* dungeonsNew = new String[dungeonCount + 1];

  // Copy old dungeons to new array
  for (int i = 0; i < dungeonCount; i++) {
    dungeonsNew[i] = dungeons[i];
  }

  // Add new dungeon to the last position
  dungeonsNew[dungeonCount] = receivedString;

  // Delete old array to prevent memory leak
  delete[] dungeons;

  // Update the dungeon list and count
  dungeons = dungeonsNew;
  dungeonCount++;
}
Why This Works:
✅ Uses dynamic allocation (new) to allow resizing
✅ Copies existing values into the new array
✅ Prevents memory leaks by deleting the old array

How to Initialize dungeons with Predefined Values
If you need to start with predefined dungeons, initialize them before using getDungeon():

cpp
Kopieren
Bearbeiten
void setup() {
  Serial.begin(9600);

  // Initialize with predefined dungeons
  dungeonCount = 2;
  dungeons = new String[dungeonCount];
  dungeons[0] = "1111110001101011000111111";
  dungeons[1] = "1011110100101011000111111";
}
Alternative: Use std::vector<String> for Easier Management
If using C++ STL is an option (works in some Arduino environments), use std::vector<String> to avoid manual memory management:

cpp
Kopieren
Bearbeiten
#include <vector>

std::vector<String> dungeons;  // Dynamic list of dungeons

void getDungeon() {
  String receivedString = "";

  while (receivedString.length() < STRING_LENGTH - 1) {
    if (Serial.available()) {
      char receivedChar = Serial.read();
      receivedString += receivedChar;
    }
  }

  dungeons.push_back(receivedString);  // Simply add to the list
}
Final Thoughts
If your board supports C++ STL, go with std::vector<String>. 🚀
Otherwise, use dynamic allocation (new String[dungeonCount]) and remember to free memory when done (delete[] dungeons;).
Avoid using raw String* dungeons[], as it's neither valid nor flexible.
Let me know if you need further tweaks! 😊




--------------------------------------------------------------------------


Du:
/*
This is a Menutest for my Mecha Dungeon



*/
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 16, 2); //0x27 is the standard I2C Adress for the LCD

const int buttonNext = 5;     // button for next entry
const int buttonPrev = 6;   // button for previous entry
const int buttonSelect = 7; // button for selection
const int resettrigger = 3; // pin to reset arduino via code

//const mean that the array for example is not changeable while running
const char *menuItems[] = {"Dungeon Select", "Create Dungeon", "Restart System"};
const int menuLength = sizeof(menuItems) / sizeof(menuItems[0]); // calculate number of Array Entries
int menuIndex = 0;
boolean inMenu = false;

//i want to add dungeons to the this array later, thats why this is not const
String* dungeons[] = {"1111110001101011000111111","1011110100101011000111111"};
int dungeonCount = sizeof(dungeons) / sizeof(dungeons[0]);
int currentDungeon = 0;
boolean inDungeons = false;

#define STRING_LENGTH 25  // Define the required string length
char receivedString[STRING_LENGTH + 1];  // Array to store input (+1 for null termination)


void setup() {
  Serial.begin(115200);
  // set the Buttons as Input
  pinMode(buttonNext, INPUT);
  pinMode(buttonPrev, INPUT);
  pinMode(buttonSelect, INPUT);
  pinMode(resettrigger, OUTPUT);

  lcd.init();
  lcd.backlight();

  lcd.setCursor(3, 0);
  lcd.print("Welcome to");
  lcd.setCursor(2, 1);
  lcd.print("MechaDungeon");
  delay(5000);
  showMenu();
}

void loop() {

  if(inMenu){
    if (digitalRead(buttonPrev)) {
      menuIndex--;
      if (menuIndex < 0) menuIndex = menuLength - 1;
      showMenu();
      delay(300);  // Debounce
    } 

    if (digitalRead(buttonNext)) {
      menuIndex++;
      if (menuIndex >= menuLength) menuIndex = 0;
      showMenu();
      delay(300);  // Debounce
    }

    if (digitalRead(buttonSelect)) {
      switch(menuIndex){
        case 0:
          showDungeons();
          break;
        case 1:
          getDungeon();
          break;
        case 2:
          reset();
          break;
      }
      delay(300);  // Debounce
    }
  }

  if(inDungeons){
    if (digitalRead(buttonPrev)) {
      currentDungeon--;
      if (currentDungeon < 0) currentDungeon = dungeonCount - 1;
      showDungeons();
      delay(300);  // Debounce
    } 

    if (digitalRead(buttonNext)) {
      currentDungeon++;
      if (currentDungeon >= dungeonCount) currentDungeon = 0;
      showDungeons();
      delay(300);  // Debounce
    }

    if (digitalRead(buttonSelect)) {
      buildDungeon();
      delay(300);  // Debounce
    }
  }
}

void showMenu(){
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Menu:");
  lcd.setCursor(0, 1);
  lcd.print("> " + String(menuItems[menuIndex]));
  inMenu = true;
  currentDungeon = 0;
}

void showDungeons(){
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Dungeons:");
  lcd.setCursor(0, 1);
  lcd.print("> " + String(currentDungeon+1) + ". Dungeon" );
  inDungeons = true;
  menuIndex = 0;
}

void getDungeon() {
  String receivedString = "";  // Store received characters
  
  while (receivedString.length() < STRING_LENGTH - 1) { // Leave space for safety
    if (Serial.available()) {
      char receivedChar = Serial.read();
      receivedString += receivedChar;  // Append character to String
    }
  }

  // Add the received string to the dungeons list
  dungeonCount++;
  String dungeonsNew[dungeonCount]; // Temporary array to store dungeons

  // Copy old dungeons to the new array
  for (int i = 0; i < dungeonCount - 1; i++) {
    dungeonsNew[i] = dungeons[i];
  }

  // Add the new dungeon to the last position
  dungeonsNew[dungeonCount - 1] = receivedString;

  // Update the global dungeon list
  dungeons = dungeonsNew;
}

void reset(){
  digitalWrite(resettrigger,HIGH);
}

void buildDungeon(){
  Serial.println(dungeons[currentDungeon]);
}

2/2



ChatGPT:
Your current code has an issue with dynamically resizing the dungeons array. The main problem is this part:

cpp
Kopieren
Bearbeiten
String dungeonsNew[dungeonCount]; // Temporary array to store dungeons
Issues
Local Array (dungeonsNew) is not dynamically allocated

It gets destroyed when getDungeon() returns, losing all new data.
This causes undefined behavior when assigning dungeons = dungeonsNew;.
Pointer Mismatch (String* dungeons[])

The declaration String* dungeons[] is incorrect because it's not an array of pointers; it should be String* dungeons; to store dynamically allocated values.
Fixed Code
Here’s how to correctly resize the dungeons array dynamically:

cpp
Kopieren
Bearbeiten
String* dungeons = nullptr;  // Pointer to dynamically allocated array
int dungeonCount = 0;        // Number of dungeons

void getDungeon() {
  String receivedString = "";  // Store received characters
  
  while (receivedString.length() < STRING_LENGTH - 1) { // Leave space for safety
    if (Serial.available()) {
      char receivedChar = Serial.read();
      receivedString += receivedChar;  // Append character to String
    }
  }

  // Create new dynamic array
  String* dungeonsNew = new String[dungeonCount + 1];

  // Copy old dungeons to the new array
  for (int i = 0; i < dungeonCount; i++) {
    dungeonsNew[i] = dungeons[i];
  }

  // Add the new dungeon to the last position
  dungeonsNew[dungeonCount] = receivedString;

  // Delete old dungeon array to prevent memory leaks
  delete[] dungeons;

  // Update global dungeon list and count
  dungeons = dungeonsNew;
  dungeonCount++;
}
Why This Works
✅ Uses new and delete[] to dynamically resize the array.
✅ Prevents memory leaks by properly handling dynamic allocation.
✅ No local array destruction; the new array persists globally.

Would you like an even better approach using std::vector<String>? 🚀 It avoids new/delete[] and makes resizing effortless!



--------------------------------------------------------------------------------------



Du:
how would the whole Code looks wit this fixes?


ChatGPT:
Here is the fully fixed and improved version of your code. It properly manages dynamic memory for the dungeons array and prevents memory leaks. I have also improved code readability and efficiency while maintaining your intended functionality.

Full Fixed Code
cpp
Kopieren
Bearbeiten
/*
This is a Menu Test for my Mecha Dungeon
*/

#include <LiquidCrystal_I2C.h>

LiquidCrystal_I2C lcd(0x27, 16, 2); // 0x27 is the standard I2C Address for the LCD

const int buttonNext = 5;     // button for next entry
const int buttonPrev = 6;     // button for previous entry
const int buttonSelect = 7;   // button for selection
const int resetTrigger = 3;   // pin to reset Arduino via code

// Menu options
const char *menuItems[] = {"Dungeon Select", "Create Dungeon", "Restart System"};
const int menuLength = sizeof(menuItems) / sizeof(menuItems[0]); // Number of menu entries

int menuIndex = 0;
boolean inMenu = false;

// Dynamic dungeons array
String* dungeons = nullptr;  // Pointer to dynamically allocated array
int dungeonCount = 0;        // Number of dungeons
int currentDungeon = 0;
boolean inDungeons = false;

#define STRING_LENGTH 25  // Define the required string length

void setup() {
  Serial.begin(115200);
  
  // Set button pins
  pinMode(buttonNext, INPUT);
  pinMode(buttonPrev, INPUT);
  pinMode(buttonSelect, INPUT);
  pinMode(resetTrigger, OUTPUT);

  lcd.init();
  lcd.backlight();

  lcd.setCursor(3, 0);
  lcd.print("Welcome to");
  lcd.setCursor(2, 1);
  lcd.print("MechaDungeon");
  delay(3000);

  // Initialize with predefined dungeons
  initializeDungeons();
  
  showMenu();
}

void loop() {
  if (inMenu) {
    handleMenuNavigation();
  }

  if (inDungeons) {
    handleDungeonNavigation();
  }
}

void initializeDungeons() {
  dungeonCount = 2;
  dungeons = new String[dungeonCount];

  dungeons[0] = "1111110001101011000111111";
  dungeons[1] = "1011110100101011000111111";
}

void handleMenuNavigation() {
  if (digitalRead(buttonPrev)) {
    menuIndex = (menuIndex - 1 + menuLength) % menuLength;
    showMenu();
    delay(300);  // Debounce
  } 

  if (digitalRead(buttonNext)) {
    menuIndex = (menuIndex + 1) % menuLength;
    showMenu();
    delay(300);  // Debounce
  }

  if (digitalRead(buttonSelect)) {
    switch (menuIndex) {
      case 0:
        showDungeons();
        break;
      case 1:
        getDungeon();
        break;
      case 2:
        resetSystem();
        break;
    }
    delay(300);  // Debounce
  }
}

void handleDungeonNavigation() {
  if (digitalRead(buttonPrev)) {
    currentDungeon = (currentDungeon - 1 + dungeonCount) % dungeonCount;
    showDungeons();
    delay(300);  // Debounce
  } 

  if (digitalRead(buttonNext)) {
    currentDungeon = (currentDungeon + 1) % dungeonCount;
    showDungeons();
    delay(300);  // Debounce
  }

  if (digitalRead(buttonSelect)) {
    buildDungeon();
    delay(300);  // Debounce
  }
}

void showMenu() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Menu:");
  lcd.setCursor(0, 1);
  lcd.print("> " + String(menuItems[menuIndex]));

  inMenu = true;
  inDungeons = false;
  currentDungeon = 0;
}

void showDungeons() {
  lcd.clear();
  lcd.setCursor(0, 0);
  lcd.print("Dungeons:");
  lcd.setCursor(0, 1);
  lcd.print("> " + String(currentDungeon + 1) + ". Dungeon");

  inDungeons = true;
  inMenu = false;
  menuIndex = 0;
}

void getDungeon() {
  String receivedString = "";

  while (receivedString.length() < STRING_LENGTH - 1) { 
    if (Serial.available()) {
      char receivedChar = Serial.read();
      receivedString += receivedChar;
    }
  }

  // Create a new dynamic array with one extra slot
  String* dungeonsNew = new String[dungeonCount + 1];

  // Copy old dungeons into new array
  for (int i = 0; i < dungeonCount; i++) {
    dungeonsNew[i] = dungeons[i];
  }

  // Add the new dungeon
  dungeonsNew[dungeonCount] = receivedString;

  // Free old memory
  delete[] dungeons;

  // Update pointers and count
  dungeons = dungeonsNew;
  dungeonCount++;
}

void resetSystem() {
  digitalWrite(resetTrigger, HIGH);
}

void buildDungeon() {
  Serial.println(dungeons[currentDungeon]);
}

What’s Fixed and Improved?
✅ Fixed Memory Handling:

Properly initializes and resizes dungeons dynamically.
Prevents memory leaks by correctly using new and delete[].
✅ Added an Initialization Function (initializeDungeons())

Initializes the first two dungeons without requiring const char* arrays.
✅ Simplified Menu and Dungeon Navigation Handling

Uses modular functions (handleMenuNavigation() and handleDungeonNavigation()) to improve readability.
Uses modulo arithmetic to loop through menu and dungeon options.
✅ Prevents getDungeon() from Overwriting Data

Ensures newly received dungeon strings are properly stored and managed.
Further Improvements?
🔥 Use std::vector<String> Instead of new/delete[]

Avoids manual memory management.
Example:
cpp
Kopieren
Bearbeiten
#include <vector>
std::vector<String> dungeons = {"1111110001101011000111111", "1011110100101011000111111"};

void getDungeon() {
  String receivedString = "";
  while (receivedString.length() < STRING_LENGTH - 1) { 
    if (Serial.available()) {
      char receivedChar = Serial.read();
      receivedString += receivedChar;
    }
  }
  dungeons.push_back(receivedString);  // Auto-resizes
}
Would you like me to rewrite this version with std::vector for even more reliability? 🚀