Merge branch 'master' of github.com:ralucado/WaveGGJ17

Resources/shader.frag

@@ -6,7 +6,7 @@ float rand(vec2 n) {
 }
 
 float line(float p, float x, float glow) {
-    if (abs(p - x) < 0.025) return 1; 
+    if (abs(p - x) < 0.025) return 1.; 
     return 1. - pow(abs(p - x), glow);
 }
 

VaporWaveWars/VaporWaveWars.pro

@@ -15,7 +15,8 @@ SOURCES += main.cpp \
     combat.cpp \
     player.cpp \
     iaenemy.cpp \
-    actor.cpp
+    actor.cpp \
+    soundmanager.cpp
 
 HEADERS += \
     game.hpp \
@@ -29,4 +30,5 @@ HEADERS += \
     combat.hpp \
     player.hpp \
     iaenemy.hpp \
-    actor.hpp
+    actor.hpp \
+    soundmanager.hpp

VaporWaveWars/actor.cpp

@@ -1,8 +1,13 @@
 #include "actor.hpp"
-Actor::Actor() {}
+Actor::Actor() {
+    score = 0;
+    animate = PlayerState::attacking;
+    this->character = new Character(0);
+}
 
 Actor::Actor(int num) {
-    animate = true;
+    score = 0;
+    animate = PlayerState::attacking;
     this->character = new Character(num);
 }
 
@@ -12,18 +17,30 @@ void Actor::draw(sf::RenderWindow *window) {
 
 bool Actor::update(float deltaTime, sf::RenderWindow *window) {
     character->update(deltaTime);
-    if (animate) {
+    if (animate == PlayerState::attacking) {
         character->setState(PlayerState::attacking);
-        animate = false;
+        animate = PlayerState::inMidle;
+    }
+    else if (animate == PlayerState::inMidle) {
+        if (character->isLastFrame()) animate = PlayerState::idle;
     }
     return this->updateLogic(deltaTime, window);
 }
 
-void Actor::hitBy(Compas enemy) const {
+bool Actor::hitBy(Compas enemy) const {
     if (enemy == compas) std::cout << "dodge" << std::endl;
     else std::cout << "hit" << std::endl;
+    return enemy == compas;
 }
 
 Compas Actor::getAttack() const {
     return compas;
 }
+
+void Actor::upScore() {
+    ++score;
+}
+
+int Actor::getScore() const {
+    return score;
+}

VaporWaveWars/actor.hpp

@@ -12,12 +12,15 @@ public:
     Actor(int num);
     bool update(float deltaTime, sf::RenderWindow *window);
     void draw(sf::RenderWindow *window);
-    void hitBy(Compas enemy) const;
+    bool hitBy(Compas enemy) const;
     Compas getAttack() const;
     virtual bool event(sf::Event e) = 0;
+    void upScore();
+    int getScore() const;
 protected:
+    int score;
     Compas compas;
-    bool animate;
+    PlayerState::playerState animate;
     virtual bool updateLogic(float deltaTime, sf::RenderWindow *window) = 0;
 private:
     Character *character;

VaporWaveWars/combat.cpp

@@ -8,6 +8,8 @@ Combat::Combat() {
 //    enemy = new IaEnemy(1);
     enemy = new Player(1);
     initShader();
+    SoundManager::load();
+    SoundManager::playMusic("music");
 }
 
 Combat::Combat(bool ia) {
@@ -45,7 +47,11 @@ void Combat::updateEvents(sf::Event e) {
     if (playerOneTurn) {
         bool aux = player->event(e);
         if (!aux) { //end of player one ritm
-            if (!attacking) player->hitBy(enemy->getAttack());
+            if (!attacking) {
+                if(!player->hitBy(enemy->getAttack())) enemy->upScore();
+                std::cout << "player1: " << player->getScore() << std::endl;
+                std::cout << "player2: " << enemy->getScore() << std::endl;
+            }
             else playerOneTurn = aux;
             attacking = !attacking;
         }
@@ -58,7 +64,11 @@ void Combat::updateEvents(sf::Event e) {
 
 void Combat::enemyManager(bool aux) {
     if (aux) {
-        if (!attacking) enemy->hitBy(player->getAttack());
+        if (!attacking) {
+            if(!enemy->hitBy(player->getAttack())) player->upScore();
+            std::cout << "player1: " << player->getScore() << std::endl;
+            std::cout << "player2: " << enemy->getScore() << std::endl;
+        }
         else playerOneTurn = aux;
         attacking = !attacking;
     }

VaporWaveWars/combat.hpp

@@ -7,6 +7,7 @@
 #include "player.hpp"
 #include "iaenemy.hpp"
 #include "actor.hpp"
+#include "soundmanager.hpp"
 
 class Combat : public Scene {
 public:

VaporWaveWars/commons.hpp

@@ -11,8 +11,8 @@
 
 const int SCENE_NUM = 4;
 
-#define MARGEERR 0.30f
+#define MARGEERR 0.05f
-#define BLACKVALUE 0.00025f
+#define BLACKVALUE 0.60f
 #define W_WIDTH  800
 #define W_HEIGHT 600
 const std::string WORK_DIR(getenv("WORK_DIR"));
@@ -41,7 +41,7 @@ namespace GameScene {
 }
 
 namespace PlayerState {
-    enum playerState{idle, attacking};
+    enum playerState{idle, attacking, inMidle};
 }
 
 #endif // COMMONS_HPP

VaporWaveWars/iaenemy.cpp

@@ -1,6 +1,6 @@
 #include "iaenemy.hpp"
 
-IaEnemy::IaEnemy() : Actor(1) {}
+IaEnemy::IaEnemy() : Actor() {}
 IaEnemy::IaEnemy(int numplayer): Actor(numplayer) {}
 bool IaEnemy::updateLogic(float deltaTime, sf::RenderWindow *window) {
 

VaporWaveWars/mygame.cpp

@@ -3,14 +3,17 @@
 MyGame::MyGame() {
     _scene = GameScene::menu;
     _scenes = std::vector<Scene*>(SCENE_NUM);
-    _scenes[GameScene::menu] = &_menu;
+    _menu = new Menu;
-    _scenes[GameScene::inGame] = &_combat;
+    _scenes[GameScene::menu] = _menu;
-    _scenes[GameScene::help] = &_menu;
+    _scenes[GameScene::inGame] = _combat;
-    _scenes[GameScene::credits] = &_menu;
+    _scenes[GameScene::help] = _menu;
+    _scenes[GameScene::credits] = _menu;
     std::cout << "in menu" << std::endl;
 }
 
 MyGame::~MyGame() {
+    delete _menu;
+    delete _combat;
 }
 
 MyGame* i(){
@@ -18,6 +21,12 @@ MyGame* i(){
 
 void MyGame::changeScene(GameScene::gameScene n){
     _scene = n;
+    if(_scenes[_scene] == NULL){
+        if(_scene == GameScene::inGame){
+            _combat = new Combat;
+            _scenes[_scene] = _combat;
+        }
+    }
 }
 
 // Main game loop

VaporWaveWars/mygame.hpp

@@ -4,17 +4,19 @@
 
 #include "menu.hpp"
 #include "combat.hpp"
+#include "soundmanager.hpp"
+
 class MyGame : public Game{
-public:
+    public:
         MyGame();
         virtual ~MyGame();
         static MyGame* i();
         void changeScene(GameScene::gameScene n);
-private:
+    private:
         GameScene::gameScene _scene;
         std::vector<Scene*> _scenes;
-     Menu _menu;
+        Menu* _menu = NULL;
-     Combat _combat;
+        Combat* _combat = NULL;
         virtual void update(float deltaTime, sf::RenderWindow *window) final override;
         virtual void draw(sf::RenderWindow *window) final override;
 };

VaporWaveWars/player.cpp

@@ -2,10 +2,12 @@
 
 Player::Player(int num) : Actor(num) {
     compas = Compas();
+    error = false;
 }
 
-Player::Player() : Actor(1) {
+Player::Player() : Actor() {
     compas = Compas();
+    error = false;
 }
 
 bool Player::updateLogic(float deltaTime, sf::RenderWindow *window) {
@@ -16,10 +18,19 @@ bool Player::updateLogic(float deltaTime, sf::RenderWindow *window) {
 bool Player::event(sf::Event e) {
     switch(e.type) {
     case (sf::Event::KeyPressed):
-        if(e.key.code == sf::Keyboard::C) compas.start();
+        if(e.key.code == sf::Keyboard::C) {
+            compas.start();
+            error = false;
+        }
         if(e.key.code == sf::Keyboard::Space) {
+            if (animate == PlayerState::idle && !error) {
                 compas.add();
-            if (compas.isPressed() && !animate) animate = true;
+                if (compas.isPressed()) animate = PlayerState::attacking;
+            }
+            else {
+                compas.end();
+                error = true; //weird?
+            }
         }
         break;
     case (sf::Event::KeyReleased):

VaporWaveWars/player.hpp

@@ -12,6 +12,8 @@ public:
 protected:
     bool updateLogic(float deltaTime, sf::RenderWindow *window);
 
+private:
+    bool error;
 };
 
 #endif // PLAYER_H

VaporWaveWars/soundmanager.cpp

@@ -0,0 +1,140 @@
+#include "soundmanager.hpp"
+
+//PLACE HERE A FORWARD DECLARATION OF YOUR STATIC VARIABLES
+//sf::SoundBuffer     SoundManager::SOUND_NAME;
+//sf::Music           SoundManager::MUSIC_NAME;
+
+/* Example:
+sf::Music           SoundManager::overWorldMusic;*/
+sf::Music     SoundManager::worldMusic;
+sf::SoundBuffer     SoundManager::atk1;
+sf::SoundBuffer     SoundManager::atk2;
+sf::SoundBuffer     SoundManager::atk3;
+sf::SoundBuffer     SoundManager::atk4;
+sf::SoundBuffer     SoundManager::atk5;
+sf::SoundBuffer     SoundManager::atk6;
+sf::SoundBuffer     SoundManager::atk7;
+sf::SoundBuffer     SoundManager::atk8;
+sf::SoundBuffer     SoundManager::atk9;
+sf::SoundBuffer     SoundManager::atk10;
+sf::SoundBuffer     SoundManager::atk11;
+sf::SoundBuffer     SoundManager::atk12;
+sf::SoundBuffer     SoundManager::atk13;
+sf::SoundBuffer     SoundManager::atk14;
+sf::SoundBuffer     SoundManager::atk15;
+sf::SoundBuffer     SoundManager::atk16;
+sf::SoundBuffer     SoundManager::atk17;
+sf::SoundBuffer     SoundManager::atk18;
+sf::SoundBuffer     SoundManager::atk19;
+sf::SoundBuffer     SoundManager::atk20;
+
+
+std::map<std::string, sf::Sound> SoundManager::soundMap;
+std::map<std::string, sf::Music> SoundManager::musicMap;
+std::map<std::string, sf::Sound>::iterator SoundManager::sit;
+std::map<std::string, sf::Music>::iterator SoundManager::mit;
+
+
+void SoundManager::load(){
+
+    //LOAD HERE YOUR SOUNDS AND MUSIC
+    /* Example: */
+    musicMap["music"].openFromFile(WORK_DIR+"Resources/Sounds/wave.wav");
+
+    ASSERT(atk1.loadFromFile(WORK_DIR+"Resources/Sounds/Samples/1.wav"));
+    soundMap["atk1"].setBuffer(atk1);
+    ASSERT(atk2.loadFromFile(WORK_DIR+"Resources/Sounds/Samples/2.wav"));
+    soundMap["atk2"].setBuffer(atk2);
+    ASSERT(atk3.loadFromFile(WORK_DIR+"Resources/Sounds/Samples/3.wav"));
+    soundMap["atk3"].setBuffer(atk3);
+    ASSERT(atk4.loadFromFile(WORK_DIR+"Resources/Sounds/Samples/4.wav"));
+    soundMap["atk4"].setBuffer(atk4);
+    ASSERT(atk5.loadFromFile(WORK_DIR+"Resources/Sounds/Samples/5.wav"));
+    soundMap["atk5"].setBuffer(atk5);
+    ASSERT(atk6.loadFromFile(WORK_DIR+"Resources/Sounds/Samples/6.wav"));
+    soundMap["atk6"].setBuffer(atk6);
+    ASSERT(atk7.loadFromFile(WORK_DIR+"Resources/Sounds/Samples/7.wav"));
+    soundMap["atk7"].setBuffer(atk7);
+    ASSERT(atk8.loadFromFile(WORK_DIR+"Resources/Sounds/Samples/8.wav"));
+    soundMap["atk8"].setBuffer(atk8);
+    ASSERT(atk9.loadFromFile(WORK_DIR+"Resources/Sounds/Samples/9.wav"));
+    soundMap["atk9"].setBuffer(atk9);
+    ASSERT(atk10.loadFromFile(WORK_DIR+"Resources/Sounds/Samples/10.wav"));
+    soundMap["atk10"].setBuffer(atk10);
+    ASSERT(atk11.loadFromFile(WORK_DIR+"Resources/Sounds/Samples/11.wav"));
+    soundMap["atk11"].setBuffer(atk11);
+    ASSERT(atk12.loadFromFile(WORK_DIR+"Resources/Sounds/Samples/12.wav"));
+    soundMap["atk12"].setBuffer(atk12);
+    ASSERT(atk13.loadFromFile(WORK_DIR+"Resources/Sounds/Samples/13.wav"));
+    soundMap["atk13"].setBuffer(atk13);
+    ASSERT(atk14.loadFromFile(WORK_DIR+"Resources/Sounds/Samples/14.wav"));
+    soundMap["atk14"].setBuffer(atk14);
+    ASSERT(atk15.loadFromFile(WORK_DIR+"Resources/Sounds/Samples/15.wav"));
+    soundMap["atk15"].setBuffer(atk15);
+    ASSERT(atk16.loadFromFile(WORK_DIR+"Resources/Sounds/Samples/16.wav"));
+    soundMap["atk16"].setBuffer(atk16);
+    ASSERT(atk17.loadFromFile(WORK_DIR+"Resources/Sounds/Samples/17.wav"));
+    soundMap["atk17"].setBuffer(atk17);
+    ASSERT(atk18.loadFromFile(WORK_DIR+"Resources/Sounds/Samples/18.wav"));
+    soundMap["atk18"].setBuffer(atk18);
+    ASSERT(atk19.loadFromFile(WORK_DIR+"Resources/Sounds/Samples/19.wav"));
+    soundMap["atk19"].setBuffer(atk19);
+    ASSERT(atk20.loadFromFile(WORK_DIR+"Resources/Sounds/Samples/20.wav"));
+    soundMap["atk20"].setBuffer(atk20);
+
+}
+
+
+
+void SoundManager::playSound(std::string name){
+    sit = soundMap.find(name);
+    if (sit != soundMap.end()) (sit->second).play();
+}
+
+void SoundManager::playMusic(std::string name){
+mit = musicMap.find(name);
+if (mit != musicMap.end()) (mit->second).play();
+
+}
+
+void SoundManager::stopMusic(std::string name){
+    mit = musicMap.find(name);
+    if (mit != musicMap.end()) (mit->second).stop();
+
+}
+
+void SoundManager::pauseMusic(std::string name){
+    mit = musicMap.find(name);
+    if (mit != musicMap.end()) (mit->second).pause();
+
+}
+
+void SoundManager::setLoop(bool loop, std::string name){
+    mit = musicMap.find(name);
+    if (mit != musicMap.end()) (mit->second).setLoop(loop);
+
+}
+
+void SoundManager::setPitch(float pitch, std::string name){
+    mit = musicMap.find(name);
+    if (mit != musicMap.end()) (mit->second).setPitch(pitch);
+}
+
+void SoundManager::setVolume(float volume, std::string name){
+    mit = musicMap.find(name);
+    if (mit != musicMap.end()) (mit->second).setVolume(volume);
+}
+
+void SoundManager::setPosition(float x, float y, float z, std::string name){
+    mit = musicMap.find(name);
+    if (mit != musicMap.end()) (mit->second).setPosition(x,y,z);
+}
+
+
+void SoundManager::setGlobalSoundVolumen(float volume) {
+    for (auto it = soundMap.begin(); it != soundMap.end(); ++it) (it->second).setVolume(volume);
+}
+
+void SoundManager::setGlobalMusicVolumen(float volume) {
+    for (auto it = musicMap.begin(); it != musicMap.end(); ++it) (it->second).setVolume(volume);
+}

VaporWaveWars/soundmanager.hpp

@@ -0,0 +1,62 @@
+#ifndef SOUNDMANAGER_HPP
+#define SOUNDMANAGER_HPP
+
+#include <map>
+#include <iostream>
+#include "commons.hpp"
+//#define SOUND static sf::Sound
+
+class SoundManager {
+
+    public:
+        static void load();
+
+        static void playSound(std::string name);
+        static void playMusic(std::string name);
+        static void stopMusic(std::string name);
+        static void pauseMusic(std::string name);
+        static void setLoop(bool loop, std::string name);
+        static void setPitch(float pitch, std::string name);
+        static void setVolume(float volume, std::string name);
+        static void setPosition(float x, float y, float z, std::string name);
+        static void setGlobalSoundVolumen(float volume);
+        static void setGlobalMusicVolumen(float volume);
+
+    private:
+
+
+        //INITIALIZE YOUR VARIABLES AS STATIC sf::Music or sf::SoundBuffer
+        /* Example:*/
+        static sf::Music     worldMusic;
+        static sf::SoundBuffer     atk1;
+        static sf::SoundBuffer     atk2;
+        static sf::SoundBuffer     atk3;
+        static sf::SoundBuffer     atk4;
+        static sf::SoundBuffer     atk5;
+        static sf::SoundBuffer     atk6;
+        static sf::SoundBuffer     atk7;
+        static sf::SoundBuffer     atk8;
+        static sf::SoundBuffer     atk9;
+        static sf::SoundBuffer     atk10;
+        static sf::SoundBuffer     atk11;
+        static sf::SoundBuffer     atk12;
+        static sf::SoundBuffer     atk13;
+        static sf::SoundBuffer     atk14;
+        static sf::SoundBuffer     atk15;
+        static sf::SoundBuffer     atk16;
+        static sf::SoundBuffer     atk17;
+        static sf::SoundBuffer     atk18;
+        static sf::SoundBuffer     atk19;
+        static sf::SoundBuffer     atk20;
+
+
+
+
+        static std::map<std::string, sf::Sound> soundMap;
+        static std::map<std::string, sf::Music> musicMap;
+        static std::map<std::string, sf::Sound>::iterator sit;
+        static std::map<std::string, sf::Music>::iterator mit;
+
+};
+
+#endif // SOUNDMANAGER_HPP