Un poco de entrenamiento

No esta completo

src/defs/chara_data.h

@@ -62,6 +62,7 @@ struct CharacterData {
 
     uint8_t stage;
     uint8_t attribute;
+    uint8_t spriteAttackId;
 
     uint32_t initialSleepTime;
     uint32_t initialWakeupTime;

src/defs/defs.h

@@ -100,6 +100,9 @@
 #define POOPING_SCREEN 24
 #define HAPPY_SCREEN 25
 
+// TRAINING MODES
+#define TRAINING_SCREEN_1 30
+
 // SMALL UI ICONS (UI.BIN)
 #define POOP_ICON 0
 #define FOOD_ICON 1

src/draw/draw.h

@@ -12,5 +12,6 @@ void draw_drawBackground(TFT_eSprite &bg, int spr_w, int spr_h, int factor);
 void draw_drawSpriteCentered(
     TFT_eSprite &spr, struct SpriteData* spriteData, uint8_t spriteNumber, uint8_t factor, bool flipped = false, int y = -1
 );
+void draw_drawAttacks(TFT_eSprite &sprite, struct SpriteData* attackSpriteData, uint8_t x, uint8_t y, uint8_t attackType, uint8_t attackSprite, uint8_t factor, bool flipped = false);
 
 #endif

src/draw/draw_attacks.cpp

@@ -0,0 +1,17 @@
+#include "draw.h"
+#include "defs/sprite_data.h"
+
+
+void draw_drawAttacks(TFT_eSprite &sprite, struct SpriteData* attackSpriteData, uint8_t x, uint8_t y, uint8_t attackType, uint8_t attackSprite, uint8_t factor, bool flipped) {
+    switch(attackType) {
+        case 1:
+            draw_drawSprite(sprite, x, y, attackSpriteData, attackSprite, factor, flipped);
+            draw_drawSprite(sprite, x, y + 48, attackSpriteData, attackSprite, factor, flipped);
+            break;
+        
+        case 0:
+        default:
+            draw_drawSprite(sprite, x, y, attackSpriteData, attackSprite, factor, flipped);
+            break;
+    }
+}

src/main.cpp

@@ -13,7 +13,7 @@
 #include "vpet/lines/lines.h"
 #include "energy/energy.h"
 #include "driver/rtc_io.h"
-
+#include "menu/training/training_screens.h"
 
 const char* TAG = "[MAIN]";
 
@@ -185,6 +185,10 @@ void loop() {
         case EVOLUTION_SCREEN:
             menu_evolutionScreen(bg, sprite, &mainCharacterSprites);
             break;
+
+        case TRAINING_SCREEN_1:
+            training_screenTraining1(bg, sprite, &mainCharacterSprites, &uiElementsData);
+            break;
     }
 
     if (screenKey == IDLE_SCREEN || screenKey == OFF_SCREEN) {

src/menu/menu_screen.cpp

@@ -47,6 +47,11 @@ void menu_drawCurrentMenuOption(TFT_eSprite &bg, TFT_eSprite &icon, struct Sprit
                 menu_sleepScreen_sleepAction();
                 break;
 
+            case TRAIN_SCREEN_MENU:
+                screenKey = TRAINING_SCREEN_1;
+                return;
+                break;
+
             case POOP_SCREEN_MENU:
                 menuKey = STATUS_SCREEN;
                 screenKey = CLEAR_POOP_SCREEN;

src/menu/training/training_screen1.cpp

@@ -0,0 +1,68 @@
+#include "vpet/training/training.h"
+#include "defs/defs.h"
+#include "defs/chara_data.h"
+#include "defs/sprite_data.h"
+#include "buttons/buttons.h"
+#include "display/display.h"
+#include "draw/draw.h"
+
+void training_screenTraining1(
+    TFT_eSprite &bg, TFT_eSprite &sprite,
+    struct SpriteData* mainCharaData, struct SpriteData* attackSprites
+) {
+    draw_drawBackground(bg, 90, 90, 3);
+    draw_drawSpriteCentered(sprite, mainCharaData, 11, 6);
+    
+    tone(SPK_PIN, 4100, 100);
+    tone(SPK_PIN, 3500, 100);
+
+    tft_drawBuffer();
+
+    delay(500);
+
+    draw_drawBackground(bg, 90, 90, 3);
+    draw_drawSpriteCentered(sprite, mainCharaData, 0, 6);
+    tft_drawCenteredText("PUSH!!", 4, 190);
+
+    tft_drawBuffer();
+
+    uint8_t attackPower = 0;
+    uint64_t currentTime = lastUpdateTime = esp_timer_get_time();
+    
+    while (currentTime - lastUpdateTime < 8000000) {
+        currentTime = esp_timer_get_time();
+
+        uint8_t buttonsRead = buttons_getPressedButtons();
+
+        switch (buttonsRead) {
+        case 8:
+            attackPower++;
+            break;
+        
+        case 2:
+            screenKey = MENU_SCREEN;
+            menuKey = TRAIN_SCREEN_MENU;
+            return;
+            break;
+
+        default:
+            break;
+        }
+    }
+
+    uint8_t attackResult;
+    if (attackPower > 20) {
+        attackResult = ATTACK_PATTERN_EXCELLENT;
+    } else if (attackPower <= 20 && attackPower > 16) {
+        attackResult = ATTACK_PATTERN_GREAT;
+    } else if (attackPower <= 16 && attackPower > 10) {
+        attackResult = ATTACK_PATTERN_GOOD;
+    } else if (attackPower <= 10 && attackPower > 6) {
+        attackResult = ATTACK_PATTERN_BAD;
+    } else {
+        attackResult = ATTACK_PATTERN_MEDIOCRE;
+    }
+
+
+    training_displayTrainingResult(bg, sprite, mainCharaData, attackSprites, attackResult);
+}

src/menu/training/training_screens.h

@@ -0,0 +1,11 @@
+#ifndef TRAINING_SCREENS_H
+#define TRAINING_SCREENS_H
+
+#include <TFT_eSPI.h>
+
+void training_screenTraining1(
+    TFT_eSprite &bg, TFT_eSprite &sprite,
+    struct SpriteData* mainCharaData, struct SpriteData* attackSprites
+);
+
+#endif

src/vpet/evolution/evolution.cpp

@@ -56,6 +56,7 @@ void change_replaceCharaData(uint8_t nextCharaId) {
     charaData.ap = currentEvalCharacter->ap;
     charaData.stage = currentEvalCharacter->stage;
     charaData.attribute = currentEvalCharacter->attribute;
+    charaData.spriteAttackId = currentEvalCharacter->attackSprite;
     charaData.initialSleepTime = currentEvalCharacter->sleepTime;
     charaData.initialWakeupTime = currentEvalCharacter->wakeTime;
     charaData.initialChangeTimer = currentEvalCharacter->changeTime;

src/vpet/lines/on_hatch_finished.cpp

@@ -21,6 +21,7 @@ void lines_onHatchComplete() {
 
     charaData.stage = currentLine[currentCharacter]->characters[0].stage;
     charaData.attribute = currentLine[currentCharacter]->characters[0].attribute;
+    charaData.spriteAttackId = currentLine[currentCharacter]->characters[0].attackSprite;
     
     charaData.sleepTime = charaData.initialSleepTime = currentLine[currentCharacter]->characters[0].sleepTime;
     charaData.wakeupTime = charaData.initialWakeupTime = currentLine[currentCharacter]->characters[0].wakeTime;

src/vpet/training/training.h

@@ -3,9 +3,11 @@
 
 #include <TFT_eSPI.h>
 
-void training_screenTraining1(
-    TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &sprite,
-    struct SpriteData* mainCharaData, struct SpriteData* attackSprites
+void training_displayTrainingResult(
+    TFT_eSprite &bg, TFT_eSprite &sprite,
+    struct SpriteData* mainCharaData, struct SpriteData* attackSprites, uint8_t trainingResult
 );
+void training_trainingAttackSounds();
+
 
 #endif

src/vpet/training/training_resultScreen.cpp

@@ -0,0 +1,119 @@
+#include "training.h"
+#include "draw/draw.h"
+#include "defs/defs.h"
+#include "defs/chara_data.h"
+#include "display/display.h"
+
+#define NUM_ROUNDS 5
+
+uint8_t patternExcellent[NUM_ROUNDS] = {1, 1, 1, 1, 1};
+uint8_t patternGreat[NUM_ROUNDS] = {1, 1, 0, 1, 0};
+uint8_t patternGood[NUM_ROUNDS] = {0, 1, 0, 1, 1};
+uint8_t patternBad[NUM_ROUNDS] = {1, 0, 1, 0, 0};
+uint8_t patternMediocre[NUM_ROUNDS] = {0, 0, 0, 0, 0};
+
+void training_displayTrainingResult(
+    TFT_eSprite &bg, TFT_eSprite &sprite,
+    struct SpriteData* mainCharaData, struct SpriteData* attackSprites, uint8_t trainingResult
+) {
+    pauseLoop = true;
+
+    charaData.effort++;
+    charaData.strengthCareMistakeTimer = charaData.initialChangeTimer;
+
+    uint8_t* pattern = NULL;
+    switch (trainingResult) {
+        case ATTACK_PATTERN_EXCELLENT:
+            pattern = patternExcellent;
+            screenKey = HAPPY_SCREEN;
+
+            charaData.strength += 2;
+            charaData.weight -= 4;
+            if (charaData.weight < charaData.minWeight) {
+                charaData.weight -= charaData.minWeight;
+            }
+
+            break;
+
+        case ATTACK_PATTERN_GREAT:
+            pattern = patternGreat;
+            screenKey = HAPPY_SCREEN;
+
+            charaData.strength += 2;
+            charaData.weight -= 2;
+            if (charaData.weight < charaData.minWeight) {
+                charaData.weight = charaData.minWeight;
+            }
+
+            break;
+
+        case ATTACK_PATTERN_GOOD:
+            pattern = patternGood;
+            screenKey = HAPPY_SCREEN;
+
+            charaData.strength += 1;
+            charaData.weight -= 2;
+            if (charaData.weight < charaData.minWeight) {
+                charaData.weight = charaData.minWeight;
+            }
+            
+            break;
+
+        case ATTACK_PATTERN_BAD:
+            pattern = patternBad;
+            screenKey = IDLE_SCREEN;
+
+            charaData.weight--;
+            if (charaData.weight < charaData.minWeight) {
+                charaData.weight = charaData.minWeight;
+            }
+
+            break;
+
+        case ATTACK_PATTERN_MEDIOCRE:
+        default:
+            pattern = patternMediocre;
+            screenKey = IDLE_SCREEN;
+            break;
+    }
+
+
+    for (int i = 0; i < NUM_ROUNDS; i++) {
+        training_trainingAttackSounds();
+        for (int j = 78; j >= 0; j -= 6) {
+            draw_drawBackground(bg, 90, 90, 3);
+            draw_drawSprite(sprite, 126, 72, mainCharaData, 11, 6);
+            tft_clearBuffer(sprite, TFT_TRANSPARENT);
+            draw_drawAttacks(sprite, attackSprites, j, 72, pattern[i], charaData.spriteAttackId, 6);
+            tft_clearBuffer(sprite, TFT_TRANSPARENT);
+            
+            tft_drawBuffer();
+        }
+
+        delay(100);
+    }
+
+
+    lastPressedButtonTime = esp_timer_get_time();
+    pauseLoop = false;
+}
+
+// nOT FANCY
+void training_trainingAttackSounds() {
+    tone(SPK_PIN, 4100, 25);
+    tone(SPK_PIN, 3700, 25);
+    tone(SPK_PIN, 4100, 25);
+    tone(SPK_PIN, 3700, 25);
+    tone(SPK_PIN, 4100, 25);
+    tone(SPK_PIN, 3700, 25);
+    tone(SPK_PIN, 4100, 25);
+    tone(SPK_PIN, 3700, 25);
+    tone(SPK_PIN, 3700, 25);
+    tone(SPK_PIN, 3100, 25);
+    tone(SPK_PIN, 3700, 25);
+    tone(SPK_PIN, 3100, 25);
+    tone(SPK_PIN, 3700, 25);
+    tone(SPK_PIN, 3100, 25);
+    tone(SPK_PIN, 3700, 25);
+    tone(SPK_PIN, 3100, 25);
+}

src/vpet/training/training_screen1.cpp

@@ -1,36 +0,0 @@
-#include "training.h"
-#include "defs/defs.h"
-#include "defs/chara_data.h"
-#include "defs/sprite_data.h"
-#include "buttons/buttons.h"
-
-void training_screenTraining1(
-    TFT_eSprite &composite, TFT_eSprite &bg, TFT_eSprite &sprite,
-    struct SpriteData* mainCharaData, struct SpriteData* attackSprites
-) {
-    uint8_t attackPower = 0;
-
-    while (true) {
-        uint8_t buttonsRead = buttons_getPressedButtons();
-        switch (buttonsRead)
-        {
-        case 8:
-            attackPower++;
-            break;
-        
-        case 2:
-            screenKey = IDLE_SCREEN;
-            return;
-            break;
-
-        default:
-            break;
-        }
-
-        uint64_t currentTime = esp_timer_get_time();
-        if (currentTime - lastUpdateTime > 10000000) {
-            // Display attack animation...
-            // NOT YET SLOW DOWN
-        }
-    }
-}

src/vpet/vpet/vpet.cpp

@@ -278,8 +278,6 @@ void vpet_runVpetTasks() {
 }
 
 void vpet_debugTimers(uint8_t diffSec) {
-    printf("[DEBUG] diffSec=%i\n", diffSec);
-
     if (charaData.hatched) {
         printf("[MAIN]: Hunger timer %d, hunger %d\n", charaData.hungerCareMistakeTimer, charaData.hunger);
         printf("[MAIN]: Strength timer %d, strength %d\n", charaData.strengthCareMistakeTimer, charaData.strength);