added music

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/character.cpp

@@ -3,14 +3,14 @@
 Character::Character(int player){
     playerNum = player;
     ASSERT(texture.loadFromFile(spriteFile));
-    height = texture.getSize().y/5;
+    height = texture.getSize().y/6;
-    width = texture.getSize().x/5;
+    width = texture.getSize().x/4;
-    next = timestamp = indexX = 0;
+    timestamp = indexX = 0;
     indexY = magicNumber;
     setTexture(texture);
     sf::IntRect rect = sf::IntRect(indexX*width, indexY*height, width, height);
     setTextureRect(rect);
-    actualState = previousState = PlayerState::idle;
+    actualState = PlayerState::idle;
 
     if (playerNum == 0){
         setPosition(posX1, posY1);
@@ -18,7 +18,7 @@ Character::Character(int player){
     }
     else{
         setPosition(posX2, posY2);
-        magicNumber = 2;
+        magicNumber = 3;
     }
 }
 
@@ -40,15 +40,23 @@ void Character::update(float deltaTime){
 }
 
 void Character::setState(PlayerState::playerState state){
-    previousState = actualState;
     actualState = state;
     if (state == PlayerState::idle){
         indexX = 0;
         indexY = 0 + magicNumber;
     }
-    else{
+    else if (state == PlayerState::attacking){
         indexX = 0;
         indexY = 1 + magicNumber;
     }
+    else if (false /*state == PlayerState::damaged*/){
+        indexX = 0;
+        indexY = 2 + magicNumber;
+    }
 }
 
+bool Character::isLastFrame(){
+    return indexX == 3;
+}
+
+

VaporWaveWars/character.hpp

@@ -19,14 +19,15 @@ private:
     sf::Texture texture;
     int indexX, indexY, width, height;
     int playerNum;
-    PlayerState::playerState actualState, previousState;
+    PlayerState::playerState actualState;
-    float timestamp, next;
+    float timestamp;
 
 public:
     Character();
     Character(int player);
     void update(float deltaTime);
     void setState(PlayerState::playerState state);
+    bool isLastFrame();
 
 };
 

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) {

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"));

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/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