NonBlockingGame3D.h

Go to the documentation of this file.

#ifndef NONBLOCKING_GAME_3D_H
#define NONBLOCKING_GAME_3D_H
 
#include <GameBase3D.h>
#include <InputHelper.h>
 
namespace bridges {
    namespace game {
 
        class NonBlockingGame3D : public GameBase3D {
            private:
                using GameBase3D::render;
                using GameBase3D::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:
                NonBlockingGame3D(int assignmentID, std::string username,
                    std::string apikey)
                    : GameBase3D(assignmentID, username, apikey) {
 
                    registerKeyListener(&ih);
                }
 
                virtual ~NonBlockingGame3D() = default;
 
                void start() {
                    timeOfLastFrame = localclock::now();
                    initialize();
 
                    render();
 
                    exit(0);
                    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