NonBlockingGame.h

Go to the documentation of this file.

#ifndef NONBLOCKING_GAME_H
#define NONBLOCKING_GAME_H
 
#include <GameBase.h>
#include <InputHelper.h>
#include <InputStateMachine.h>
 
namespace bridges {
    namespace game {
 
        class NonBlockingGame : public GameBase {
            private:
                using GameBase::render;
                using GameBase::registerKeyListener;
 
                typedef std::chrono::steady_clock localclock;
 
                InputHelper ih;
                InputStateMachine upSM;
                InputStateMachine downSM;
                InputStateMachine leftSM;
                InputStateMachine rightSM;
 
                InputStateMachine qSM;
                InputStateMachine spaceSM;
 
                InputStateMachine wSM;
                InputStateMachine aSM;
                InputStateMachine sSM;
                InputStateMachine dSM;
 
                double fps = 30.;
 
                localclock::time_point timeOfLastFrame;
 
                void handleFrameRate() {
                    using std::chrono::seconds;
                    using std::chrono::microseconds;
                    using std::chrono::duration_cast;
 
                    microseconds frametime = duration_cast<microseconds>(seconds(1l)) / (int)fps;
 
                    localclock::time_point theoretical_next_frame = timeOfLastFrame + frametime;
 
                    auto wait_time = theoretical_next_frame - localclock::now();
 
                    if (wait_time.count() > 0) {
                        microseconds wait_time_in_us = duration_cast<microseconds>(wait_time);
                        usleep(wait_time_in_us.count());
                    }
 
                    timeOfLastFrame = localclock::now();
                }
 
                void updateInputState() {
                    upSM.update();
                    downSM.update();
                    leftSM.update();
                    rightSM.update();
 
                    qSM.update();
                    spaceSM.update();
 
                    wSM.update();
                    aSM.update();
                    sSM.update();
                    dSM.update();
                }
 
            public:
                NonBlockingGame(int assignmentID, std::string username,
                    std::string apikey, int nbRow = 10, int nbCol = 10)
                    : GameBase(assignmentID, username, apikey, nbRow, nbCol),
                      ih(),
                      upSM([this]() ->bool {return this->ih.keyUp();}),
                      downSM([this]() ->bool {return this->ih.keyDown();}),
                      leftSM([this]() ->bool {return this->ih.keyLeft();}),
                      rightSM([this]() ->bool {return this->ih.keyRight();}),
 
                      qSM([this]() ->bool {return this->ih.keyQ();}),
                      spaceSM([this]() ->bool {return this->ih.keySpace();}),
 
                      wSM([this]() ->bool {return this->ih.keyW();}),
                      aSM([this]() ->bool {return this->ih.keyA();}),
                      sSM([this]() ->bool {return this->ih.keyS();}),
                      dSM([this]() ->bool {return this->ih.keyD();}) {
                    if (debug)
                        std::cerr << "nbRow: " << nbRow << " nbCol: " <<
                            nbCol << std::endl;
 
                    if (nbRow * nbCol > 32 * 32) {
                        throw "NonBlockingGame can not have a grid of more than 32x32 (or a combination(so 16x64 is ok; 16x128 is not)";
                    }
 
                    registerKeyListener(&ih);
 
                }
 
                virtual ~NonBlockingGame() = default;
 
                void start() {
                    timeOfLastFrame = localclock::now();
                    initialize();
 
                    long framelimit = -1; //negative means no limit
                    {
                        char* str_limit = getenv("FORCE_BRIDGES_FRAMELIMIT");
                        if (str_limit != nullptr) {
                            std::stringstream ss;
                            ss << str_limit;
                            ss >> framelimit;
                            std::cerr << "Setting framelimit to " << framelimit << std::endl;
                        }
                    }
                    long frame = 0;
                    while (!gameover()) {
                        updateInputState();
                        gameLoop();
                        render();
                        handleFrameRate();
                        frame++;
                        if (framelimit > 0 && frame > framelimit)
                            quit();
                    }
                }
 
            protected:
                double getFrameRate() const {
                    return fps;
                }
 
                bool keyLeft() {
                    return ih.keyLeft();
                }
 
                bool keyLeftJustPressed() {
                    return leftSM.justPressed();
                }
 
                bool keyLeftStillPressed() {
                    return leftSM.stillPressed();
                }
                bool keyLeftJustNotPressed() {
                    return leftSM.justNotPressed();
                }
                bool keyLeftStillNotPressed() {
                    return leftSM.stillNotPressed();
                }
 
                bool keyLeftFire() {
                    return leftSM.fire();
                }
 
                void keyLeftSetupFire(int f) {
                    leftSM.setFireCooldown(f);
                }
                bool keyRight() {
                    return ih.keyRight();
                }
                bool keyRightJustPressed() {
                    return rightSM.justPressed();
                }
                bool keyRightStillPressed() {
                    return rightSM.stillPressed();
                }
                bool keyRightJustNotPressed() {
                    return rightSM.justNotPressed();
                }
                bool keyRightStillNotPressed() {
                    return rightSM.stillNotPressed();
                }
                bool keyRightFire() {
                    return rightSM.fire();
                }
                void keyRightSetupFire(int f) {
                    rightSM.setFireCooldown(f);
                }
                bool keyUp() {
                    return ih.keyUp();
                }
 
                bool keyUpJustPressed() {
                    return upSM.justPressed();
                }
 
                bool keyUpStillPressed() {
                    return upSM.stillPressed();
                }
 
                bool keyUpJustNotPressed() {
                    return upSM.justNotPressed();
                }
 
                bool keyUpStillNotPressed() {
                    return upSM.stillNotPressed();
                }
 
                bool keyUpFire() {
                    return upSM.fire();
                }
 
                void keyUpSetupFire(int f) {
                    upSM.setFireCooldown(f);
                }
 
                bool keyDown() {
                    return ih.keyDown();
                }
 
                bool keyDownJustPressed() {
                    return downSM.justPressed();
                }
 
                bool keyDownStillPressed() {
                    return downSM.stillPressed();
                }
 
                bool keyDownJustNotPressed() {
                    return downSM.justNotPressed();
                }
                bool keyDownStillNotPressed() {
                    return downSM.stillNotPressed();
                }
                bool keyDownFire() {
                    return downSM.fire();
                }
 
                void keyDownSetupFire(int f) {
                    downSM.setFireCooldown(f);
                }
 
                bool keyW() {
                    return ih.keyW();
                }
 
                bool keyWJustPressed() {
                    return wSM.justPressed();
                }
 
                bool keyWStillPressed() {
                    return wSM.stillPressed();
                }
 
                bool keyWJustNotPressed() {
                    return wSM.justNotPressed();
                }
 
                bool keyWStillNotPressed() {
                    return wSM.stillNotPressed();
                }
                bool keyWFire() {
                    return wSM.fire();
                }
 
                void keyWSetupFire(int f) {
                    wSM.setFireCooldown(f);
                }
 
                bool keyA() {
                    return ih.keyA();
                }
 
                bool keyAJustPressed() {
                    return aSM.justPressed();
                }
 
                bool keyAStillPressed() {
                    return aSM.stillPressed();
                }
 
                bool keyAJustNotPressed() {
                    return aSM.justNotPressed();
                }
 
                bool keyAStillNotPressed() {
                    return aSM.stillNotPressed();
                }
                bool keyAFire() {
                    return aSM.fire();
                }
 
                void keyASetupFire(int f) {
                    aSM.setFireCooldown(f);
                }
 
                bool keyS() {
                    return ih.keyS();
                }
 
                bool keySJustPressed() {
                    return sSM.justPressed();
                }
 
 
                bool keySStillPressed() {
                    return sSM.stillPressed();
                }
 
                bool keySJustNotPressed() {
                    return sSM.justNotPressed();
                }
 
                bool keySStillNotPressed() {
                    return sSM.stillNotPressed();
                }
                bool keySFire() {
                    return sSM.fire();
                }
 
                void keySSetupFire(int f) {
                    sSM.setFireCooldown(f);
                }
 
                bool keyD() {
                    return ih.keyD();
                }
                bool keyDJustPressed() {
                    return dSM.justPressed();
                }
 
                bool keyDStillPressed() {
                    return dSM.stillPressed();
                }
 
                bool keyDJustNotPressed() {
                    return dSM.justNotPressed();
                }
 
                bool keyDStillNotPressed() {
                    return dSM.stillNotPressed();
                }
                bool keyDFire() {
                    return dSM.fire();
                }
 
                void keyDSetupFire(int f) {
                    dSM.setFireCooldown(f);
                }
                bool keyQ() {
                    return ih.keyQ();
                }
                bool keyQJustPressed() {
                    return qSM.justPressed();
                }
 
                bool keyQStillPressed() {
                    return qSM.stillPressed();
                }
 
                bool keyQJustNotPressed() {
                    return qSM.justNotPressed();
                }
 
                bool keyQStillNotPressed() {
                    return qSM.stillNotPressed();
                }
                bool keyQFire() {
                    return qSM.fire();
                }
 
                void keyQSetupFire(int f) {
                    qSM.setFireCooldown(f);
                }
                bool keySpace() {
                    return ih.keySpace();
                }
                bool keySpaceJustPressed() {
                    return spaceSM.justPressed();
                }
 
                bool keySpaceStillPressed() {
                    return spaceSM.stillPressed();
                }
 
                bool keySpaceJustNotPressed() {
                    return spaceSM.justNotPressed();
                }
 
                bool keySpaceStillNotPressed() {
                    return spaceSM.stillNotPressed();
                }
                bool keySpaceFire() {
                    return spaceSM.fire();
                }
 
                void keySpaceSetupFire(int f) {
                    spaceSM.setFireCooldown(f);
                }
        };
    }
}
 
#endif