Successful - Implemented page that connect to Binary and Addition game in emulator and real hardware

Author: Ando14-Rookie

addition_game/addition_game.c

@@ -48,7 +48,7 @@ void initAdditionGame(void) {
         overflowOccur += 1;
         printf("Question at round %d will cause overflow.\n", currentRound);
     }
-    
+
     // Make all LED off first in `led_array`
     fill_color(offColor);
 
@@ -57,7 +57,7 @@ void initAdditionGame(void) {
 
     // The game will keep running until user get the answer correct, unless
     // they wish to stop the game
-    while (!stopPlaying && currentPage == ADDITION_GAME) {
+    while (!stopPlaying) {
         // Activate keyboard I, J, K, L press input
         checkMoveButton();
 
@@ -103,7 +103,6 @@ void initAdditionGame(void) {
                 // Stop playing and go back to the previous page, namely
                 // `PAINTING_SPACE`
                 currentPage = prevPageState;
-                currentAddGame = ADDITION_GAME_IDLE;
                 stopPlaying = true;
             }
         }
@@ -152,8 +151,13 @@ void initAdditionGame(void) {
                 currentRound += 1;
                 currentAddGame = ADDITION_GAME_IDLE;
 
+                // TODO NEXT: CHECK IF THE HARDWARE CODE WORKS
+                // ENSURE TO INTEGRATE BOTH BINARYGAME AND ADDITION GAME TOGETHER
+
+                // Check if next round questions from Round 1 to 4 will cause overflow or not
+                // Round 0 has been handled in the beginning
                 if(currentRound < 5){
-                    // Check if next round questions will cause overflow or not
+                    
                     if(numberA + numberB > 15){
                         overflowOccur += 1;
                         printf("Question at round %d will cause overflow.\n", currentRound);
@@ -184,8 +188,10 @@ void initAdditionGame(void) {
         roundEntered[i] = 0;
     }
 
-    // Reset the game state (2nd time)
+    // Reset the game state
     currentAddGame = ADDITION_GAME_IDLE;
+    // Reset the overflow counter
+    overflowOccur = 0;
 
     // As soon as the function stop, render back the real saved canvas
     for (int i = 0; i < NUM_LEDS; i++) {
@@ -208,6 +214,10 @@ void initAdditionGame(void) {
  * @param questionB The 4-bits binary question 2
  **/
 static inline void handleScenario(uint8_t row, uint8_t idx, uint8_t questionA, uint8_t questionB) {
+    #ifdef DEBUG_VERBOSE
+    printf("handleScenario called with row=%d idx=%d\n", row, idx);
+    #endif
+    
     // Handle User Input by changing to selected
     // Only works for user input
     if (row == 3 && idx >= 1 && idx <= 5) {
@@ -308,19 +318,19 @@ static inline void renderQuestion(uint8_t questionA, uint8_t questionB) {
     // Decorative overlay spots, per row
     static const uint8_t row7Spots[] = {1, 2, 3, 4, 5, 6};
     for (int i = 0; i < 6; i++) {
-        setColorLEDScaled(7 * 8 + row7Spots[i], greyColor, brightnessDivisor);
+        setColorLEDScaled(7 * 8 + row7Spots[i], magentaColor, brightnessDivisor);
     }
 
-    setColorLEDScaled(6 * 8 + 6, greyColor, brightnessDivisor);
-    setColorLEDScaled(6 * 8 + 1, greyColor, brightnessDivisor);
+    setColorLEDScaled(6 * 8 + 6, magentaColor, brightnessDivisor);
+    setColorLEDScaled(6 * 8 + 1, magentaColor, brightnessDivisor);
 
-    setColorLEDScaled(5 * 8 + 6, greyColor, brightnessDivisor);
+    setColorLEDScaled(5 * 8 + 6, magentaColor, brightnessDivisor);
     setColorLEDScaled(5 * 8 + 1, onColorBlue, brightnessDivisor);
 
-    setColorLEDScaled(4 * 8 + 6, greyColor, brightnessDivisor);
-    setColorLEDScaled(4 * 8 + 5, greyColor, brightnessDivisor);
-    setColorLEDScaled(4 * 8 + 4, greyColor, brightnessDivisor);
-    setColorLEDScaled(4 * 8 + 3, greyColor, brightnessDivisor);
+    setColorLEDScaled(4 * 8 + 6, magentaColor, brightnessDivisor);
+    setColorLEDScaled(4 * 8 + 5, magentaColor, brightnessDivisor);
+    setColorLEDScaled(4 * 8 + 4, magentaColor, brightnessDivisor);
+    setColorLEDScaled(4 * 8 + 3, magentaColor, brightnessDivisor);
 
     for (int col = 0; col <= 2; col++) {
         setColorLEDScaled(4 * 8 + col, onColorBlue, brightnessDivisor);

binary_game/binary_game.c

@@ -40,7 +40,7 @@ void initBinaryGame(void) {
 
     // The game will keep running until user get the answer correct, unless
     // they wish to stop the game
-    while (!stopPlaying && currentPage == BINARY_GAME) {
+    while (!stopPlaying) {
 
         // Activate keyboard I, J, K, L press input
         checkMoveButton();
@@ -91,7 +91,7 @@ void initBinaryGame(void) {
         }
 
         // Only works after user move the pointer one by one
-        if ((currentGame == BINARY_GAME_IDLE) && buttonPressed == 1) {
+        if ((currentGame == BINARY_GAME_IDLE) && (!stopPlaying) && buttonPressed == 1) {
             // Render normally
             renderBinaryGame(randomNumber);
             // printf("currentGame is %d \n", currentGame);

binary_game/multiple_round.c

@@ -1,10 +1,17 @@
-#include "multiple_round.h"
+#include "./multiple_round.h"
+
+// Function prototype declaration
+static inline void renderChooseGameMode(void);
 
 enum RoundStatus roundStatus[5] = {
     ROUND_IDLE, ROUND_IDLE, ROUND_IDLE, ROUND_IDLE, ROUND_IDLE};
 
 int8_t roundEntered[5] = {0};
 
+
+enum GameplayMode playGameMode = CHOOSE_GAME;
+
+// Store the overflow state logo
 const uint8_t overflowLogo[6][5] = {
     [0] = {0b10000111, 0b10011101, 0b11011101, 0b10100101, 0b11000111},
     [1] = {0b10000010, 0b10011110, 0b11011010, 0b10100010, 0b11000111},
@@ -13,6 +20,129 @@ const uint8_t overflowLogo[6][5] = {
     [4] = {0b10000011, 0b10011101, 0b11011111, 0b10100001, 0b11000001},
     [5] = {0b10000111, 0b10011100, 0b11011111, 0b10100001, 0b11000110}};
 
+// Store the gameplay screen here
+static const char* screenPattern[8] = {
+    "12120330",
+    "21213333",
+    "12123333",
+    "21210330",
+    "00000000",
+    "02200330",
+    "22223333",
+    "00000000"
+};
+
+uint16_t chooseGamemodeScreen[7] = {0};
+
+void chooseGameMode(void) {
+    // Will stay in this mode until user presses confirm button to choose the game mode
+    bool chooseMode = false;
+    // Reset the buttonPressed variable to be 0 first
+    buttonPressed = 0;
+    // Check if the enter has been pressed or not
+    ChooseEnterPressed enterPressed = CHOOSE_GAME_NOT_ENTERED;
+    
+    // Print the emulator screen for the first time for this function
+    renderChooseGameMode();
+
+    while(!chooseMode){
+        // Activate keyboard I, J, K, L press input
+        checkMoveButton();
+
+        // Navigate pointers
+        if (BTN_JUST_PRESSED(BTN_UP)) {
+            currentposition = (NUM_LEDS + currentposition + 8) % NUM_LEDS;
+            buttonPressed = 1;
+        }
+        if (BTN_JUST_PRESSED(BTN_DOWN)) {
+            currentposition = (NUM_LEDS + currentposition - 8) % NUM_LEDS;
+            buttonPressed = 1;
+        }
+        if (BTN_JUST_PRESSED(BTN_LEFT)) {
+            currentposition = (NUM_LEDS + currentposition + 1) % NUM_LEDS;
+            buttonPressed = 1;
+        }
+        if (BTN_JUST_PRESSED(BTN_RIGHT)) {
+            currentposition = (NUM_LEDS + currentposition - 1) % NUM_LEDS;
+            buttonPressed = 1;
+        }
+        if (BTN_JUST_PRESSED(Enter_Key)) {
+            enterPressed = CHOOSE_GAME_ENTERED;
+        }
+
+        // Compute which row and col your pointer is in now
+        uint8_t row = currentposition / GRID_COLS;
+        uint8_t col = currentposition % GRID_COLS;
+        uint8_t ledIndex = row * VERTICAL_BUTTONS + col;
+
+        // Update to compare button released and pressed state
+        updateMoveButton();
+
+        if(buttonPressed == 1){
+            renderChooseGameMode();
+            // Reset state
+            buttonPressed = 0;
+        }
+
+        if(enterPressed == CHOOSE_GAME_ENTERED){
+            // If user has pressed the confirm button, then choose the game mode
+            if((ledIndex >= 8 && ledIndex <= 11) || ledIndex == 17 || ledIndex == 18){
+                playGameMode = ADDITION_GAME;
+                chooseMode = true;
+            }
+            else if((ledIndex >= 12 && ledIndex <= 15) || ledIndex == 21 || ledIndex == 22){
+                playGameMode = BINARY_GAME;
+                chooseMode = true;
+            }
+
+            // Reset back
+            enterPressed = CHOOSE_GAME_NOT_ENTERED;
+        }
+
+    }
+
+    //Reset values
+    buttonPressed = 0;
+    enterPressed = CHOOSE_GAME_NOT_ENTERED;
+}
+
+static inline void renderChooseGameMode(void) {
+    // Clear the screen first
+    fill_color(offColor);
+    // Render the game mode selection screen
+    for (uint8_t arrayRow = 0; arrayRow <= 7; arrayRow++) {
+        int8_t ledRow = 7 - arrayRow; // top (7) down to row 3
+        for (uint8_t arrayCol = 0; arrayCol < 8; arrayCol++) {
+            int ledCol = 7 - arrayCol;
+            int idx = ledRow * 8 + ledCol;
+            // '0'-'3' as ASCII characters need to be converted to actual
+            // numbers 0-3. Subtracting the character '0' does this:
+            // e.g. '2' - '0' = 50 - 48 = 2
+            uint8_t state = screenPattern[arrayRow][arrayCol] - '0';
+            switch(state){
+                case 0:
+                    setColorLEDScaled(idx, offColor, brightnessDivisor);
+                    break;
+                case 1:
+                    setColorLEDScaled(idx, onColorBlue, brightnessDivisor);
+                    break;
+                case 2:
+                    setColorLEDScaled(idx, cyanColor, brightnessDivisor);
+                    break;
+                case 3:
+                    setColorLEDScaled(idx, solidColorRed, brightnessDivisor);
+                    break;
+            }
+        }
+    }
+
+    // Draw pointer ON TOP visually (only effect led_array), doesn't touch
+    set_color(currentposition, pointerColor);
+
+    // Print the emulator screen
+    WS2812BSimpleSend(LED_PINS, (uint8_t *)led_array, NUM_LEDS * 3);
+}
+
 void renderGameRounds(void) {
     for (int8_t col = 4; col >= 0; col--) {
         // flip to match physical LED ordering
@@ -56,7 +186,7 @@ void handleGameRounds(bool answerCorrect, uint8_t roundIndex) {
                     currentGame = BINARY_GAME_CONTINUE;
                 }
                 else if (currentPage == ADDITION_GAME) {
-                    currentGame = ADDITION_GAME_CONTINUE;
+                    currentAddGame = ADDITION_GAME_CONTINUE;
                 }
                 setColorLEDScaled(roundIndex, orangeColor, brightnessDivisor);
                 printf("I got correct answer the 1st time in round %d.\n", roundIndex);
@@ -84,7 +214,7 @@ void handleGameRounds(bool answerCorrect, uint8_t roundIndex) {
                     currentGame = BINARY_GAME_CONTINUE;
                 }
                 else if (currentPage == ADDITION_GAME) {
-                    currentGame = ADDITION_GAME_CONTINUE;
+                    currentAddGame = ADDITION_GAME_CONTINUE;
                 }
                 break;
             case false:

binary_game/multiple_round.h

@@ -25,6 +25,23 @@ extern const uint8_t overflowLogo[6][5];
 // roundStatus anymore
 extern int8_t roundEntered[5];
 
+// Status for what game is being played
+enum GameplayMode {
+    CHOOSE_GAME, // 0
+    BINARY_GAME, // 1
+    ADDITION_GAME // 2
+};
+
+// Store the gameplay mode
+extern enum GameplayMode playGameMode;
+
+typedef uint8_t ChooseEnterPressed;
+#define CHOOSE_GAME_NOT_ENTERED 0
+#define CHOOSE_GAME_ENTERED 1
+
+/// @brief Let user choose which game he wants to play. Either `Binary Game` or `Addition Game`.
+void chooseGameMode(void);
+
 /**
  * @brief Call this everytime emulator screen is printed. This print the user input
  * , confirm button and quit button

data/colors.c

@@ -12,6 +12,7 @@ const color_t lightOrangeColor = {255, 230, 190};
 const color_t greyColor = {235, 235, 235};
 const color_t pointerColor = {255, 188, 100}; // Orange
 const color_t magentaColor = {255, 15, 245}; // Magenta
+const color_t cyanColor = {15, 255, 245}; // Cyan
 const color_t solidColorRed = {255, 0, 0}; // Solid Red
 const color_t lightColorRed = {255, 200, 200};  // Light Red
 const color_t whiteColor = {255, 255, 255};

data/colors.h

@@ -35,6 +35,7 @@ extern const color_t greyColor;
 extern const color_t pointerColor;
 extern const color_t magentaColor;
 extern const color_t whiteColor;
+extern const color_t cyanColor;
 extern const color_t solidColorRed;
 extern const color_t lightColorRed;
 

emulator/adriel_2026_work/emulator_driver/emulator_driver.h

@@ -21,8 +21,7 @@ typedef enum {
     CODING_LOAD_SLOT, 
     CODING_LOAD_CONFIRM,
     BRIGHTNESS_CONTROL,
-    BINARY_GAME, // Page is only for binary number learning
-    ADDITION_GAME // Page is only for binary addition learning
+    CHOOSE_GAME_CONTROL
 } PageState;
 
 extern PageState currentPage;

emulator/adriel_2026_work/extra_function.c

@@ -82,13 +82,15 @@ void handleButtonFunction(void) {
             printf("Now page state is %d\n", currentPage);
         }
         if (BTN_JUST_PRESSED(BTN_5)) {
-            printf("You selected 'BINARY GAME'.\n");
+            printf("You selected 'CHOOSE GAME PLAY'.\n");
             // Remember previous page: PAINTING_SPACE
             prevPageState = currentPage;
             // TO DO: Add function to render and handle user choosing which game to play
-            currentPage = ADDITION_GAME;
+            currentPage = CHOOSE_GAME_CONTROL;
             // Will print the page ID: 14
             printf("Now page state is %d\n", currentPage);
+            // Let user choose which game to play, either binary game or addition game
+            chooseGameMode();
         }
         if (BTN_JUST_PRESSED(BTN_6)) {
             printf("You selected 'COLOR FOR BACKGROUND'.\n");
@@ -212,12 +214,13 @@ void handleButtonFunction(void) {
         renderBrightnessSelectScreen();
     }
 
-    if(currentPage == BINARY_GAME){
+    if(currentPage == CHOOSE_GAME_CONTROL && playGameMode == BINARY_GAME){
+        printf("User has chosen `BINARY_GAME`. \n");
         initBinaryGame();
     }
 
-    if(currentPage == ADDITION_GAME){
-        // initBinaryGame();
+    if(currentPage == CHOOSE_GAME_CONTROL && playGameMode == ADDITION_GAME){
+        printf("User has chosen `ADDITION_GAME`. \n");
         initAdditionGame();
     }
 

real_hardware/Makefile

@@ -33,7 +33,8 @@ C_SOURCES := ./User/main.c \
 	./User/data/colors.c \
 	./User/data/buttons.c \
 	./User/data/music.c \
-	./User/hardware_binary_game/multiple_round.c
+	./User/hardware_binary_game/multiple_round.c \
+	./User/hardware_binary_game/addition_game.c
 
  # List of assembly source files
 ASM_SOURCES := ./Startup/startup_ch32v00x.S
@@ -69,8 +70,8 @@ ARCH_FLAGS := -march=rv32ec_zicsr_zifencei -mabi=ilp32e
 # -MP adds dummy rules to make header dependency handling safer.
 CFLAGS := $(COMMON_FLAGS) $(ARCH_FLAGS) $(INCLUDES) -std=gnu11 -MMD -MP
 
-# add this only when you want debug prints:
-# CFLAGS += -DEBUG_VERBOSE
+# KEEP the critical SDK flag so the hardware libraries don't break
+# CFLAGS += -DDEBUG_VERBOSE
 
 # Flags for compiling assembly files.
 # "-x assembler-with-cpp": tells GCC to preprocess the assembly source first, \

real_hardware/User/data/colors.c

@@ -20,11 +20,12 @@ const color_t blueColor = {33, 33, 255};
 const color_t redColor = {0, 255, 0};
 const color_t greenColor = {255, 0, 0};
 const color_t yellowColor = {255, 221, 31};
-const color_t orangeColor = {255, 150, 15};
+const color_t greyColor = {235, 235, 235};
+const color_t orangeColor = {152, 255, 16};
 const color_t lightOrangeColor = {255, 230, 190};
-const color_t purpleColor = {165, 100, 255};
-const color_t magentaColor = {255, 15, 245}; 
-const color_t whiteColor = {255, 255, 255};
+const color_t purpleColor = {30, 125, 255};
+const color_t magentaColor = {15, 255, 245}; 
+const color_t cyanColor = {255, 0, 255};
 const color_t offColor = {0, 0, 0};
 
 // clang-format on