client.hpp

Go to the documentation of this file.

#include "client/core.hpp"
 
#include <iostream>
#include <ostream>
#include <utility>
#include <unordered_map>
#include <chrono>
#include <map>
 
#include <boost/asio/ip/tcp.hpp>
#include <boost/asio/io_service.hpp>
#include <boost/filesystem.hpp>
 
#include "client/shader.hpp"
#include "client/model.hpp"
#include "client/util.hpp"
#include "client/lobbyfinder.hpp"
#include "client/gui/gui.hpp"
#include "client/camera.hpp"
#include "client/audio/audiomanager.hpp"
#include "client/constants.hpp"
#include "client/animation.hpp"
#include "client/animationmanager.hpp"
#include "client/bone.hpp"
 
#include "shared/game/sharedgamestate.hpp"
#include "shared/game/sharedobject.hpp"
#include "shared/network/packet.hpp"
#include "shared/network/session.hpp"
#include "shared/utilities/config.hpp"
#include "shared/utilities/constants.hpp"
#include "shared/utilities/typedefs.hpp"
 
#define WINDOW_WIDTH Client::getWindowSize().x
#define WINDOW_HEIGHT Client::getWindowSize().y
 
// position something a "frac" of the way across the screen
// e.g. WIDTH_FRAC(1, 4) -> a fourth of the way from the left
//      HEIGHT_FRAC(2, 3) -> two thirds of the way from the bottom
#define FRAC_WINDOW_WIDTH(num, denom) Client::window_width * static_cast<float>(num) / static_cast<float>(denom)
#define FRAC_WINDOW_HEIGHT(num, denom) Client::window_height * static_cast<float>(num) / static_cast<float>(denom)
 
using namespace boost::asio::ip;
 
class Client {
 
public:
    Client(boost::asio::io_service& io_service, GameConfig config);
 
    ~Client();
 
    bool init();
 
    bool cleanup();
 
    // Callbacks
    void displayCallback();
 
    void idleCallback();
 
    void sendPacketsToServer();
 
    void keyCallback(GLFWwindow *window, int key, int scancode, int action, int mods);
 
    void mouseCallback(GLFWwindow* window, double xposIn, double yposIn);
 
    void scrollCallback(GLFWwindow* window, double xposIn, double yposIn);
 
    void mouseButtonCallback(GLFWwindow* window, int button, int action, int mods);
 
    void charCallback(GLFWwindow* window, unsigned int codepoint);
 
    static glm::vec2 getWindowSize();
 
    static time_t getTimeOfLastKeystroke();
 
    // Getter / Setters
    GLFWwindow* getWindow() { return window; }
 
    bool connect(std::string ip_addr);
 
    AudioManager* getAudioManager();
 
    AnimationManager* getAnimManager() { return animManager; }
 
    void setWorldPos();
 
    void sendTrapEvent(bool hover, bool place, ModelType trapType);
 
    int curr_fps;
private:
    void processServerInput(bool allow_defer);
 
    GLuint gBuffer;
    GLuint gPosition, gNormal, gAlbedoSpec;
    GLuint quadVAO = 0;
    GLuint quadVBO;
    GLuint cubeVAO = 0;
    GLuint cubeVBO = 0;
 
    void configureGBuffer();
 
    void draw();
 
    void geometryPass();
 
    void lightingPass();
 
    void drawBbox(boost::optional<SharedObject> object);
 
    /* Current game state */
    SharedGameState gameState;
 
    /* Stuff for the intro cutscene, contains a whole other SharedGameState */
    std::optional<LoadIntroCutsceneEvent> intro_cutscene;
 
    /* Shader objects for various */
    std::shared_ptr<Shader> deferred_geometry_shader;
    std::shared_ptr<Shader> deferred_lighting_shader;
    std::shared_ptr<Shader> dm_deferred_lighting_shader;
    std::shared_ptr<Shader> deferred_light_box_shader;
 
    /* Character models and lighting objects, might need to move to different classes later */
    std::unique_ptr<Model> fire_player_model;
    std::unique_ptr<Model> lightning_player_model;
    std::unique_ptr<Model> water_player_model;
 
    std::unique_ptr<Model> bear_model;
    std::unique_ptr<Model> torchlight_model;
    std::unique_ptr<Model> torchpost_model;
    std::unique_ptr<Model> wall_model;
    std::unique_ptr<Model> pillar_model;
    std::unique_ptr<Model> sungod_model;
    std::unique_ptr<Model> slime_model;
    std::unique_ptr<Model> python_model;
    std::unique_ptr<Model> item_model;
    std::unique_ptr<Model> spike_trap_model;
    std::unique_ptr<Model> orb_model;
    std::unique_ptr<Model> exit_model;
    std::unique_ptr<Model> floor_model;
    std::unique_ptr<Model> arrow_model;
    std::unique_ptr<Model> arrow_trap_model;
    std::unique_ptr<Model> lava_cross_model;
    std::unique_ptr<Model> lava_vertical_model;
    std::unique_ptr<Model> lava_horizontal_model;
    std::unique_ptr<Model> lightning_model;
    std::unique_ptr<Model> chest_model;
    std::unique_ptr<Model> teleport_model;
    std::unique_ptr<Model> mirror_model;
 
    GLFWwindow *window;
 
    /* GUI */
    friend class gui::GUI;
    gui::GUI gui;
    gui::GUIState gui_state;
 
    enum class LobbyPlayerState {
        Connected,
        SelectedRole,
        Ready
    };
 
    LobbyPlayerState lobbyPlayerState;
 
    enum class RadioButtonState {
        NoneSelected,
        FirstOption,
        SecondOption
    };
 
    RadioButtonState roleSelection;
 
    AudioManager* audioManager;
 
    AnimationManager* animManager;
 
    /* Camera object representing player's current position & orientation */
    std::unique_ptr<Camera> cam;
 
    /* Flags */
    static int window_width;
    static int window_height;
 
    static time_t time_of_last_keystroke;
 
    /* Key held flags */
    bool is_held_up = false;
    bool is_held_down = false;
    bool is_held_right = false;
    bool is_held_left = false;
    bool is_held_space = false;
 
    /* DM zooming in and out flags */
    bool is_held_i = false;
    bool is_held_o = false;
 
    bool is_left_mouse_down = false;
    bool is_right_mouse_down = false;
 
    /* DM Trap Orientation Traps With Directions */
    int orientation = 0;
 
    /* Mouse position coordinates */
    float mouse_xpos = 0.0f;
    float mouse_ypos = 0.0f;
 
    double lastTime = 0.0;
    double lastFrameTime = 0.0;
 
    GameConfig config;
    tcp::resolver resolver;
    tcp::socket socket;
 
    LobbyFinder lobby_finder;
 
    basic_resolver_results<class boost::asio::ip::tcp> endpoints;
    std::shared_ptr<Session> session;
 
    glm::vec3 world_pos; // stored world pause, calculated before the GUI is rendered
 
    std::array<boost::optional<SharedObject>, MAX_POINT_LIGHTS> closest_light_sources;
 
    std::deque<Event> events_received;
 
    bool phase_change;
 
    // id of last known player which is holding the orb
    EntityID player_has_orb_global_id;
};