NonBlockingGame.h

Go to the documentation of this file.

#ifndef NONBLOCKING_GAME_H
#define NONBLOCKING_GAME_H

#include <GameBase.h>
#include <InputHelper.h>

namespace bridges {
    namespace game {

        class NonBlockingGame : public GameBase {
            private:
                using GameBase::render;
                using GameBase::registerKeyListener;

                typedef std::chrono::steady_clock localclock;

                InputHelper ih;

                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();
                }


            public:
                NonBlockingGame(int assignmentID, std::string username,
                    std::string apikey, int nbRow = 10, int nbCol = 10)
                    : GameBase(assignmentID, username, apikey, nbRow, nbCol) {
                    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()) {
                        gameLoop();
                        render();
                        handleFrameRate();
                        frame++;
                        if (framelimit > 0 && frame > framelimit)
                            quit();
                    }
                }


            protected:
                double getFrameRate() const {
                    return fps;
                }

                bool keyLeft() {
                    return ih.keyLeft();
                }

                bool keyRight() {
                    return ih.keyRight();
                }

                bool keyUp() {
                    return ih.keyUp();
                }

                bool keyDown() {
                    return ih.keyDown();
                }

                bool keyW() {
                    return ih.keyW();
                }

                bool keyA() {
                    return ih.keyA();
                }

                bool keyS() {
                    return ih.keyS();
                }

                bool keyD() {
                    return ih.keyD();
                }

                bool keyQ() {
                    return ih.keyQ();
                }

                bool keySpace() {
                    return ih.keySpace();
                }

        };
    }
}

#endif