Se ha intentado comprobar la defensa a tiempo real

VaporWaveWars/actor.hpp

@@ -15,6 +15,7 @@ public:
     bool hitBy(Compas enemy);
     Compas getAttack() const;
     virtual bool event(sf::Event e) = 0;
+    virtual DefenseResult::defenseResult event(sf::Event e, int note) = 0;
 
 protected:
     Compas compas;

VaporWaveWars/combat.cpp

@@ -4,6 +4,8 @@ Combat::Combat() {
     ia = false;
 //    ia = true;
     state = CombatState::player_atk;
+    readingCompas = false;
+    readCompas = 0;
     player = new Player(0);
     //    enemy = new IaEnemy(1);
     enemy = new Player(1);
@@ -33,6 +35,8 @@ Combat::Combat(bool ia) {
     if (ia) enemy = new IaEnemy(1);
     else enemy = new Player(1);
     initShader();
+    readingCompas = false;
+    readCompas = 0;
 }
 
 bool Combat::isAttack() const {
@@ -86,7 +90,7 @@ void Combat::initShader() {
 void Combat::update(float deltaTime, sf::RenderWindow *window) {
     player->update(deltaTime, window);
     bool aux = enemy->update(deltaTime, window);
-    if (ia) enemyManager(aux); //end of player two ia rythm
+    if (ia); //enemyManager(aux); //end of player two ia rythm
 
     time += deltaTime;
     _shader.setParameter("time", time);
@@ -140,56 +144,87 @@ void Combat::draw(sf::RenderWindow *window) {
 }
 
 void Combat::updateEvents(sf::Event e) {
-    if (isPlayerOne()) {
+    if (isPlayerOne() or !ia) {
-        bool compasFinish = !player->event(e);
+        enemyManager(e);
-        enemyManager(compasFinish);
-        if(e.type == sf::Event::KeyPressed && e.key.code == sf::Keyboard::C && !isAttack()) doMahWaves(!isPlayerOne());
-    }
-    else if (!ia) {
-        bool compasFinish = !enemy->event(e);
-        enemyManager(compasFinish);
-        if(e.type == sf::Event::KeyPressed && e.key.code == sf::Keyboard::C && !isAttack()) doMahWaves(!isPlayerOne());
     }
 }
 
-void Combat::enemyManager(bool compasFinish) {  //To do: considerar si hay ia
+void Combat::enemyManager(sf::Event e) {  //To do: considerar si hay ia
-    if(compasFinish) {
+    if(e.type == sf::Event::KeyPressed && e.key.code == sf::Keyboard::C && !isAttack()) doMahWaves(!isPlayerOne());
+
     Compas compas;
 
     switch(state) {
         case CombatState::player_def:
-                compas = enemy->getAttack();
+            if(!readingCompas) {
-                if(!player->hitBy(compas)) {
+                readingCompas = true;
-                    scoreEnemy->incrisScore();
+                readCompas = 0;
+                std::cout << "Start reading pink defense" << std::endl;
             }
+            compas = enemy->getAttack();
+            if(readCompas == compas.size()) {
                 state = CombatState::player_atk;
+                readingCompas = false;
+            }
+            else {
+                std::cout << "Reading note " << readCompas << " out of " << compas.size() << std::endl;
+                DefenseResult::defenseResult defense = player->event(e, compas.get(readCompas));
+                if(defense == DefenseResult::fail) {
+                    scoreEnemy->incrisScore();
+                    state = CombatState::player_atk;
+                    readingCompas = false;
+                }
+                else if(defense == DefenseResult::success) {
+                    ++readCompas;
+                }
+            }
             break;
         case CombatState::player_atk:
+            if(!player->event(e)) {
                 compas = player->getAttack();
                 if(compas.isFailed()) {
                     state = CombatState::enemy_atk;
                 }
                 else state = CombatState::enemy_def;
+            }
             break;
         case CombatState::enemy_def:
-                compas = player->getAttack();
+            if(!readingCompas) {
-                if(!enemy->hitBy(compas)) {
+                readingCompas = true;
-                    scorePlayer->incrisScore();
+                readCompas = 0;
+                std::cout << "Start reading blue defense" << std::endl;
             }
+            compas = player->getAttack();
+            if(readCompas < compas.size()) {
+                std::cout << "Reading note " << readCompas << " out of " << compas.size() << std::endl;
+                DefenseResult::defenseResult defense = enemy->event(e, compas.get(readCompas));
+                if(defense == DefenseResult::fail) {
+                    scorePlayer->incrisScore();
                     state = CombatState::enemy_atk;
+                    readingCompas = false;
+                }
+                else if(defense == DefenseResult::success) {
+                    ++readCompas;
+                }
+            }
+            else {
+                state = CombatState::enemy_atk;
+                readingCompas = false;
+            }
             break;
         case CombatState::enemy_atk:
+            if(!enemy->event(e)) {
                 compas = enemy->getAttack();
                 if(compas.isFailed()) {
                     state = CombatState::player_atk;
                 }
                 else state = CombatState::player_def;
+            }
             break;
         default:
             break;
     }
 }
-}
 
 void Combat::doMahWaves(bool p) {
     std::cout << "defensa jugador " << p << std::endl;

VaporWaveWars/combat.hpp

@@ -24,7 +24,8 @@ class Combat : public Scene {
         void draw(sf::RenderWindow *window) final override;
         void updateEvents(sf::Event e) final override;
     private:
-        bool playerOneTurn, ia, attacking, toEnemy;
+        bool playerOneTurn, ia, attacking, toEnemy, readingCompas;
+        int readCompas;
         Actor *player, *enemy;
         float time;
         CombatState::combatState state;
@@ -34,7 +35,7 @@ class Combat : public Scene {
         sf::Shader _shader, _shaderHalo;
         Score *scoreEnemy, *scorePlayer;
         void initShader();
-        void enemyManager(bool aux);
+        void enemyManager(sf::Event e);
         void animationTo(bool toEnemy, float deltaTime);
         bool isAttack() const;
         bool isPlayerOne() const;

VaporWaveWars/commons.hpp

@@ -50,4 +50,8 @@ namespace CombatState {
 enum combatState{player_def = 0, player_atk = 1, enemy_def = 2, enemy_atk = 3};
 }
 
+namespace DefenseResult {
+enum defenseResult{nothing = 0, success = 1, fail = 2};
+}
+
 #endif // COMMONS_HPP

VaporWaveWars/compas.cpp

@@ -39,7 +39,7 @@ void Compas::fail() {
     end();
 }
 
-void Compas::incraeseTime() {
+void Compas::increaseTime() {
     ++spaceTime;
 }
 
@@ -51,6 +51,17 @@ bool Compas::isFailed() const {
     return failed;
 }
 
+bool Compas::check(int note) {
+    std::cout << "Checking note " << note << std::endl;
+
+    bool res = false;
+    if(isPress) {
+        res = (std::abs((float) note - spaceTime) / (float) note) < (MARGEERR);
+        spaceTime = 1;
+    }
+    return res;
+}
+
 const std::vector<int>& Compas::getNotes() const
 {
     return notes;

VaporWaveWars/compas.hpp

@@ -12,18 +12,19 @@ private:
     bool failed;
     int spaceTime;
     std::vector<int> notes;
-    int get(int i) const;
-    int size() const;
 
 public:
     Compas();
+    int get(int i) const;
+    int size() const;
     void start();
     void add();
     void end();
     void fail();
-    void incraeseTime();
+    void increaseTime();
     bool isPressed() const;
     bool isFailed() const;
+    bool check(int note);
     bool operator ==(const Compas& d) const;
     const std::vector<int> &getNotes() const;
 };

VaporWaveWars/iaenemy.cpp

@@ -8,3 +8,5 @@ bool IaEnemy::updateLogic(float deltaTime, sf::RenderWindow *window) {
 }
 
 bool IaEnemy::event(sf::Event e) {return false;}
+
+DefenseResult::defenseResult IaEnemy::event(sf::Event e, int note) {return DefenseResult::fail;}

VaporWaveWars/iaenemy.hpp

@@ -8,6 +8,7 @@ public:
     IaEnemy();
     IaEnemy(int player);
     bool event(sf::Event e) final override;
+    DefenseResult::defenseResult event(sf::Event e, int note) final override;
 protected:
     bool updateLogic(float deltaTime, sf::RenderWindow *window);
 

VaporWaveWars/player.cpp

@@ -15,7 +15,7 @@ Player::Player() : Actor() {
 bool Player::updateLogic(float deltaTime, sf::RenderWindow *window) {
     time += deltaTime;
     if (time > BLACKVALUE) {
-        compas.incraeseTime();
+        compas.increaseTime();
         time = 0;
     }
     return false;
@@ -57,3 +57,44 @@ bool Player::event(sf::Event e) {
     }
     return true;
 }
+
+DefenseResult::defenseResult Player::event(sf::Event e, int note) {
+    std::cout << "Let's read an event" << std::endl;
+    switch(e.type) {
+    case (sf::Event::KeyPressed):
+        if(e.key.code == sf::Keyboard::C) {
+            std::string sample = "note"+std::to_string(rand()%4+1);
+            SoundManager::playSound(sample);
+            std::cout << "playing sample " << sample << std::endl;
+            if(!compas.isPressed()) compas.start();
+            error = false;
+        }
+        if(e.key.code == sf::Keyboard::Space) {
+            if (animate == PlayerState::idle && !error) {
+                std::cout << "Let's check notes" << std::endl;
+                bool correct = compas.check(note);
+                if(!correct) {
+                    animate = PlayerState::hurt;
+                    compas.end();
+                    return DefenseResult::fail;
+                }
+                else {
+                    animate = PlayerState::attacking;
+                    return DefenseResult::success;
+                }
+            }
+            else {
+                if (!error) {
+                    compas.fail();
+                    animate = PlayerState::hurt;
+                    error = true;
+                    return DefenseResult::fail;
+                }
+            }
+        }
+        break;
+    default:
+        break;
+    }
+    return DefenseResult::nothing;
+}

VaporWaveWars/player.hpp

@@ -9,6 +9,7 @@ public:
     Player();
     Player(int num);
     bool event(sf::Event e) final override;
+    DefenseResult::defenseResult event(sf::Event e, int note) final override;
 protected:
     bool updateLogic(float deltaTime, sf::RenderWindow *window);