spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

#pragma once
#include <SFML/Graphics.hpp>
#include "StateManager.hpp"
#include "Background.hpp"
#include "Terrain.hpp"
#include "Base.hpp"
#include "ResourceManager.hpp"
#include "ParticleSystem.hpp"
#include "Missile.hpp"
#include <vector>

#ifdef _DEBUG
#include <sstream>
#endif

class Game {
public:
    Game();
    void run();

private:
    void handleEvents();
    void spawnEnemyMissile();
    void spawnPlayerMissile();
    void updateMissiles();
    void updatePlayerMissiles();
    void updateEnemyMissiles();
    bool basesAlive();

    sf::RenderWindow window;
    ResourceManager resMan;
    Background bg;
    Terrain terrain;
    ParticleSystem pSys;
    StateManager stateManager;

    std::vector<std::unique_ptr<Missile> > enemyMissiles;
    std::vector<std::unique_ptr<Missile> > playerMissiles;

    sf::Clock clock;
    float elapsedTimeInSec = 0.f;

#ifdef _DEBUG
    sf::Font font;
    sf::Text fpsText;
#endif
};

C-/C++-Quelltext

#include "Game.hpp"

/*
 *  Initializes members.
 */
Game::Game() :
    window(sf::VideoMode(800, 600), "Lunar Defense"),
    resMan("res/img/"),
    bg (&resMan),
    terrain(&resMan) {

    srand(static_cast<unsigned int>(time(NULL)));
    window.setVerticalSyncEnabled(true);
#ifdef _DEBUG
    font.loadFromFile("res/fonts/consola.ttf");
    fpsText.setFont(font);
    fpsText.setCharacterSize(16);
    fpsText.setPosition(sf::Vector2f(0.f, 600.f - 16.f));
    fpsText.setColor(sf::Color::Yellow);
#endif
}

/*
 *  Main game loop.
 */
void Game::run() {
    while (window.isOpen()) {
        elapsedTimeInSec = clock.restart().asSeconds();
        
        handleEvents();

        window.clear();
        window.draw(bg);
        window.draw(terrain);

        updateMissiles();
        pSys.update(elapsedTimeInSec);
        pSys.render(&window);

#ifdef _DEBUG
        int fps = static_cast<int>(1 / elapsedTimeInSec + .5f);
        std::stringstream ss;
        ss << fps;
        fpsText.setString(ss.str());
        window.draw(fpsText);
#endif _DEBUG

        window.display();
    }
}

/*
 * Polls events and reacts accordingly.
 */
void Game::handleEvents() {
    sf::Event event;
    while (window.pollEvent(event)) {
        if ((event.type == sf::Event::Closed) ||
            (event.type == sf::Event::KeyPressed && event.key.code == sf::Keyboard::Escape)) {

            window.close();
        }

        if (event.type == sf::Event::MouseButtonPressed &&
            event.mouseButton.button == sf::Mouse::Left) {

            spawnPlayerMissile();
        }

        if (event.type == sf::Event::KeyPressed &&
            event.key.code == sf::Keyboard::Space) {

            spawnEnemyMissile();
        }
    }
}

/*
 *  Spawns an enemy missile from a random location at the top of the screen.
 *  The target is a random undestroyed base.
 */
void Game::spawnEnemyMissile() {
    if (basesAlive()) {
        Base* rBase = nullptr;
        rBase = terrain.getBase(Base::slots(random(0, 4)));
        while (!rBase->isAlive()) {
            rBase = terrain.getBase(Base::slots(random(0, 4)));
        }

        sf::Vector2f rBasePos = rBase->getPosition();
        std::unique_ptr<Missile> missile(new Missile(&resMan,
            sf::Vector2f(randomf(0.f, 800.f), 0.f),
            rBasePos,
            2.f,
            &pSys));
        enemyMissiles.push_back(std::move(missile));
    }
}

/*
 *  Spawns a new missile of the player from the base which is nearest to the mouse cursor and still alive.
 *  The missile's target is the position of the mouse cursor.
 */
void Game::spawnPlayerMissile() {
    if (basesAlive()) {
        Base* rBase = nullptr;
        
        for (size_t i = 0; i < 4 && rBase == nullptr; i++) {
            if (terrain.getBase(Base::slots(i))->isAlive()) {
                rBase = terrain.getBase(Base::slots(i));
            }
        }
        sf::Vector2f clickPosition(sf::Mouse::getPosition(window));
        sf::Vector2f dVector = rBase->getPosition() - clickPosition;
        float minDistance = length(dVector);
        float baseDistance = 0.f;
        Base* minBase = rBase;

        for (size_t i = 0; i < 4; i++) {
            if (terrain.getBase(Base::slots(i))->isAlive()) {
                rBase = terrain.getBase(Base::slots(i));
                dVector = rBase->getPosition() - clickPosition;
                baseDistance = length(dVector);
                if (baseDistance < minDistance) {
                    minDistance = baseDistance;
                    minBase = rBase;
                }
            }
        }

        sf::Vector2f minBasePos = minBase->getPosition();

        std::unique_ptr<Missile> missile(new Missile(&resMan,
            minBasePos,
            clickPosition,
            2.f,
            &pSys));
        playerMissiles.push_back(std::move(missile));
    }
}

/*
 *  Updates enemy and player missiles.
 */
void Game::updateMissiles() {
    updatePlayerMissiles();
    updateEnemyMissiles();
}

/*
 *  Updates player missiles according to elapsed time.
 *  Checks if a missile has reached it's target in which case the missile get destroyed.
 */
void Game::updatePlayerMissiles() {
    for (auto m = playerMissiles.begin(); m != playerMissiles.end();) {
        bool reachedTarget = false;
        sf::Vector2f mPos = (**m).getPosition();
        sf::Vector2f tPos = (**m).getTargetPosition();
        if (length(mPos - tPos) < 10.f) {
            reachedTarget = true;
        }

        if (reachedTarget) {
            m = playerMissiles.erase(m);
        }
        else {
            (**m).update(elapsedTimeInSec);
            window.draw(**m);
            m++;
        }
    }
}

/*
 *  Updates enemy missiles according to elapsed time.
 *  Checks if a missile has reached it's target base in which case base and missile get destroyed.
 */
void Game::updateEnemyMissiles() {
    for (auto m = enemyMissiles.begin(); m != enemyMissiles.end();) {
        (**m).update(elapsedTimeInSec);
        window.draw(**m);
        bool collision = false;
        for (size_t i = 0; (i < Terrain::BASE_COUNT && !collision); i++) {
            Base* b = terrain.getBase(Base::slots(i));
            if (b->isAlive() &&
                b->getBoundingRect().contains((**m).getPosition())) {
                collision = true;
                b->destroy();
            }
        }

        sf::FloatRect viewRect = sf::FloatRect(sf::Vector2f(0, 0), window.getDefaultView().getSize());
        if (collision || !(viewRect.contains((**m).getPosition()))) {
            m = enemyMissiles.erase(m);
        }
        else {
            m++;
        }
    }
}

/*
 *  Returns true if there is at least one base have not been destroyed so far.
 *  Returns false if all bases have been destroyed.
 */ 
bool Game::basesAlive() {
    bool baseAlive = false;
    for (size_t i = 0; i < 4 && !baseAlive; i++) {
        if (terrain.getBase(Base::slots(i))->isAlive()) {
            baseAlive = true;
        }
    }
    return baseAlive;
}