Messages

1

General / Re: event.type only executes every once in a while instead of when a key is press

« on: December 13, 2017, 06:11:52 pm »

Thank for your explanation. I fixed the problem passing the event to the proccesEvent function and removing the "while(window.pollEvent(event))" loop within it.

2

General / event.type only executes every once in a while instead of when a key is press

« on: December 13, 2017, 03:53:14 pm »

I'm trying to make a ship shoot every time the space key is press but the thing is that the pressing of the key is detect randomly.
The game class is the one that manage the differents screens of the game and the PlayScene class is the one that manage the behavior of the different entities. the problem is in the ProcessEvent() function.

here's the code:

Game.h

/***
 * Clase para manejar un bucle de juego con distintas escenas
 */
class Game {
public:
        /// comenzar el bucle de juego
        void run();
       
        /// cambiar la escena actual por otra
        void switchScene(BaseScene *scene);
       
        /// obtener la instancia de juego (singleton)
        static Game &getInstance();
       
        /// crear un juego especificando el modo de video y la escena inicial
        static Game &create(const sf::VideoMode &videoMode, BaseScene *scene, const string &name = "");

private:       
        sf::RenderWindow window;
        BaseScene *currentScene, *nextScene;
        sf::Clock clock;
       
        void processEvents();
        void update();
        void draw();
        static Game *instance;
        Game();
};

#endif
 

Game.cpp

Game *Game::instance = nullptr;
Game::Game(){}

Game &Game::create(const sf::VideoMode &videoMode, BaseScene *scene, const string &name){
        if(instance){
                cerr<<"ERROR: can't call create(), game already running."<<endl;
        }else{
                Game & g = getInstance();
                g.window.create(videoMode, name, sf::Style::Close);
                g.nextScene = nullptr;
                g.currentScene = scene;
                g.window.setFramerateLimit(60);
                g.clock.restart();
        }
        return getInstance();
}


Game &Game::getInstance(){
        if(!instance){
                instance = new Game();
        }
        return *instance;
}

void Game::run(){
        while(window.isOpen() && currentScene != nullptr) {
                sf::Event e;
                while(window.pollEvent(e)){
                        if(e.type == sf::Event::Closed){
                                window.close();
                        }
                }
                update();
                processEvents();
                draw();
                if(nextScene != nullptr){
                        delete currentScene;
                        currentScene = nextScene;
                        nextScene = nullptr;
                }
        }
}




void Game::update(){
        currentScene->update(clock.getElapsedTime().asSeconds());
        clock.restart();
}

void Game::processEvents(){
        currentScene->processEvent(window);
}

void Game::draw(){
        window.clear(sf::Color(0,0,0,255));
        currentScene->draw(window);
        window.display();
}

void Game::switchScene(BaseScene *scene){
        nextScene = scene;
}
 

BaseScene.h

class BaseScene {
public:
        /// constructor
        BaseScene();
       
        /// función que será invocada para actualizar la escena
        virtual void update(float elapsed);
       
        virtual void processEvent(sf::RenderWindow &w);
       
        /// función que será invocada para dibujar la escena
        virtual void draw(sf::RenderWindow &w);

        /// agrega un nuevo actor a la escena
        void add(Entity *e);
       
        /// eliminar un actor de la escena
        void remove(Entity *e);
       
private:
        vector<Entity *> entities;
        vector<Entity *> to_delete;
};

#endif
 

BaseScene

BaseScene::BaseScene() {
       
}

void BaseScene::update(float elapsed) {
        for(auto e: entities){
                e->update(elapsed);
        }
       
        // elimina actores
        for(auto d: to_delete){
                auto it = find(entities.begin(), entities.end(), d);
                if(it != entities.end()){
                        entities.erase(it);
                }
        }
        to_delete.clear();
}

void BaseScene::processEvent(sf::RenderWindow &w){
       
}

void BaseScene::draw(sf::RenderWindow &w){
        for(auto e: entities){
                e->draw(w);
        }
}

void BaseScene::add(Entity *e){
        entities.push_back(e);
}

void BaseScene::remove(Entity *e){
        to_delete.push_back(e);
}
 

PlayScene.h

class PlayScene : public BaseScene {
private:
        ScrollingBackground background;
        Player player;
        std::vector<Enemy> enemies;
        std::vector<Bullet> bullets;
public:
        PlayScene();
       
        void update (float elapsed);
        void processEvent(sf::RenderWindow &w);
        void draw (sf::RenderWindow & w);
};
 

PlayScene.cpp

PlayScene::PlayScene() {
        for (int i=0; i<5; i++){
                Enemy *enemy = new Enemy();
                enemies.push_back(*enemy);
        }
}

void PlayScene::processEvent(sf::RenderWindow &w){
        sf::Event event;
        while(w.pollEvent(event)){
                if (event.type == sf::Event::KeyPressed){
                        if (event.key.code == sf::Keyboard::Space){
                                Bullet *bullet = new Bullet(player.getPosition().x, player.getPosition().y);
                                bullet->setRotation(-90);
                                bullet->setSpeed();
                                bullets.push_back(*bullet);
                        }
                }
        }
}

void PlayScene::update (float elapsed) {
        BaseScene::update(elapsed);
       
        background.update(elapsed);
       
        player.update(elapsed);
       
        for (size_t i=0; i<enemies.size(); i++){
                enemies[i].update(elapsed);
               
                if (enemies[i].fireEvent(elapsed)){
                        Bullet *bullet = new Bullet(enemies[i].getPosition().x-25, enemies[i].getPosition().y-34);
                        bullets.push_back(*bullet);
                }
        }
       
        for (size_t i=0; i<bullets.size(); i++){
                bullets[i].update(elapsed);
               
                if (bullets[i].getPosition().y >480+5){
                        bullets.erase(bullets.begin() + i);
                }
               
                if (bullets[i].getBounds().intersects(player.getBounds())){
                        player.getHit();
                        bullets.erase(bullets.begin()+i);
                }
        }
}

void PlayScene::draw (sf::RenderWindow & w) {
        BaseScene::draw(w);
        background.draw(w);
        player.draw(w);
        for (size_t i=0; i<bullets.size(); i++){
                bullets[i].draw(w);
        }
        for (size_t i=0; i<enemies.size(); i++){
                enemies[i].draw(w);
        }
}
 

3

General / How can I show a vector of sprites?

« on: May 03, 2017, 01:01:34 am »

Hello.

I'm trying to make a game. The idea is that you control an airplane and you have to shoot to the enemy ships. The problem is that I can't make the enemy ships to appear in the window. the game compile and I don't get any error so I don't know what I'm doing wrong.

This is my code:

class Enemy.h with the class EnemyFactory that handle the texture:

class Enemy {
private:
        sf::Sprite sprite;
       
        float speed = 190.0f ;
       
        Enemy(int _maxX, int _maxY, sf::Texture _texture);
public:
        friend class EnemyFactory;
       
        sf::Sprite render();
        void update(sf::Time deltaTime);
};

class EnemyFactory{
private:
        sf::Texture texture;
public:
        EnemyFactory(){
                texture.loadFromFile("SFML-Game-Development-Book-master/03_World/Media/Textures/Raptor.png");
        }
       
        Enemy create(int _maxX, int _maxY){
                return {_maxX, _maxY, texture};
        }
};

class Enemy.cpp:

Enemy::Enemy(int _maxX, int _maxY, sf::Texture _texture) {
        sprite.setTexture(_texture);
        sprite.rotate(180);
        sprite.setScale(0.8f, 0.8f);
       
       
       
        sprite.setPosition(200,200); //-500
}

sf::Sprite Enemy::render(){
        return sprite;
}


void Enemy::update(sf::Time deltaTime){
        sprite.move(0.0f, speed * deltaTime.asSeconds());
       
        if (sprite.getPosition().y > 480){
                sprite.setPosition(200,200);  //y=-500 x=1+rand()%640
        }
}

class Bullet.h:

class Bullet {
private:

        sf::Sprite sprite;
       
        sf::Vector2f speed;
       
       
        int posX, posY;
       
        Bullet(int _posX, int _posY, sf::Texture &_texture);
       
public:
       
        friend class BulletFactory;
       
        void update(sf::Time deltaTime);
        sf::Sprite render();
};

class BulletFactory{
private:
        sf::Texture texture;
public:
        BulletFactory(){
                texture.loadFromFile("SFML-Game-Development-Book-master/10_Network/Media/Textures/misil2.png");
        }
       
        Bullet create(int _posX, int _posY){
                return {_posX, _posY, texture};
        }
};
 

Bullet.cpp:

Bullet::Bullet(int _posX, int _posY, sf::Texture &_texture) {
       
        sprite.setTexture(_texture);
        sprite.rotate(-90);
        sprite.setScale(0.1f, 0.1f);
       
        posX = _posX;
        posY = _posY;
       
        sprite.setPosition(posX, posY);
       
        speed.y = -500.0f;
}


void Bullet::update(sf::Time deltaTime){
       
        sprite.move(0, speed.y * deltaTime.asSeconds());
}

sf::Sprite Bullet::render(){
        return sprite;
}

class Game.h:

class Game {
private:
        sf::RenderWindow *mWindow;
       
        ScrollingBackground background;
       
        Aircraft aircraft;
       
        std::vector<Enemy> enemies;
        EnemyFactory enemy;
       
        std::vector<Bullet> bullets;
        BulletFactory bullet;
private:
        void proccesEvent();
        void update(sf::Time deltaTime);
        void render();
public:
        Game();
        void run();
};

Game.cpp:

Game::Game(){
        mWindow = new sf::RenderWindow(sf::VideoMode(640,480), "ventana SFML");
        mWindow->setKeyRepeatEnabled(false);
       
        for (int i; i<5; i++){
                enemies.push_back(enemy.create(640,480));
        }      
}

void Game::proccesEvent(){
        sf::Event event;
       
        while(mWindow->pollEvent(event)){
                if(event.type == sf::Event::Closed){
                        mWindow->close();
                }
               
                if (event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Space){
                        bullets.push_back(bullet.create((aircraft.getPosition().x+15), (aircraft.getPosition().y+40)));
                }
               
        }
}


void Game::update(sf::Time deltaTime){
               
        background.update(deltaTime);
       
        if (sf::Keyboard::isKeyPressed(sf::Keyboard::W)){
                aircraft.Up();
        }
        if (sf::Keyboard::isKeyPressed(sf::Keyboard::S)){
                aircraft.Down();
        }
        if (sf::Keyboard::isKeyPressed(sf::Keyboard::A)){
                aircraft.Left();
        }
        if (sf::Keyboard::isKeyPressed(sf::Keyboard::D)){
                aircraft.Right();
        }
       
        for (int j=0; j<enemies.size(); j++){
                enemies[j].update(deltaTime);
        }
       
        for (int i=0; i<bullets.size(); i++){
                bullets[i].update(deltaTime);
        }
       
        aircraft.update(deltaTime);
}

void Game::render(){
        mWindow->clear();
        mWindow->draw(background.render());
        for (int j=0; j<enemies.size(); j++){
                mWindow->draw(enemies[j].render());
        }
        for (int i=0; i<bullets.size(); i++){
                mWindow->draw(bullets[i].render());
        }
        mWindow->draw(aircraft.Render());
       
        mWindow->display();
}

void Game::run(){
        sf::Clock clock;
        while(mWindow->isOpen()){
                sf::Time deltaTime = clock.restart();
                proccesEvent();
                update(deltaTime);
                render();
        }
}

Another thing to mention is that at first the enemy ships appeared in the window and worked fine but then I added  the vector of Bullet and it stop working.
Can anyone help me?