antkeeper
/
source


								/*

								 * Copyright (C) 2017-2019  Christopher J. Howard

								 *

								 * This file is part of Antkeeper Source Code.

								 *

								 * Antkeeper Source Code is free software: you can redistribute it and/or modify

								 * it under the terms of the GNU General Public License as published by

								 * the Free Software Foundation, either version 3 of the License, or

								 * (at your option) any later version.

								 *

								 * Antkeeper Source Code is distributed in the hope that it will be useful,

								 * but WITHOUT ANY WARRANTY; without even the implied warranty of

								 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

								 * GNU General Public License for more details.

								 *

								 * You should have received a copy of the GNU General Public License

								 * along with Antkeeper Source Code.  If not, see <http://www.gnu.org/licenses/>.

								 */


								#ifndef GAME_HPP

								#define GAME_HPP


								#include <emergent/emergent.hpp>

								using namespace Emergent;


								#include "state-machine.hpp"

								#include "entity/entity-id.hpp"

								#include "scheduled-function-event.hpp"

								#include "resources/string-table.hpp"

								#include <array>

								#include <map>

								#include <optional>

								#include <string>

								#include <vector>

								#include <fstream>


								class GameState;

								class SplashState;

								class SandboxState;

								class UIContainer;

								class UIBatcher;

								class UIImage;

								class UILabel;

								class UIRenderPass;

								class ClearRenderPass;

								class SkyRenderPass;

								class ShadowMapRenderPass;

								class LightingRenderPass;

								class SilhouetteRenderPass;

								class FinalRenderPass;

								class ResourceManager;

								class CameraRig;

								class OrbitCam;

								class FreeCam;

								class Tool;

								class Lens;

								class Forceps;

								class Brush;

								class ParticleSystem;

								class EntityManager;

								class ComponentManager;

								class SystemManager;

								class SoundSystem;

								class CollisionSystem;

								class RenderSystem;

								class CameraSystem;

								class ToolSystem;

								class BehaviorSystem;

								class SteeringSystem;

								class LocomotionSystem;

								class TerrainSystem;

								class ComponentBase;

								class Menu;

								class MenuItem;

								class CommandInterpreter;

								class Logger;

								enum class ComponentType;


								class Game:

									public Application,

									public StateMachine,

									public EventHandler<ScheduledFunctionEvent>

								{

								public:

									/**

									 * Creates a game instance.

									 *

									 * @param argc Argument count

									 * @param argv Argument list

									 */

									Game(int argc, char* argv[]);


									/// Destroys a game instance.

									virtual ~Game();


									/**

									 * Gets a string in the current language.

									 *

									 * @param name Name of the string.

									 * @return String in the current language.

									 */

									std::string getString(const std::string& name, std::optional<std::size_t> languageIndex = std::nullopt) const;


									/**

									 * Changes the current language.

									 *

									 * @param languageIndex Index of the language to use.

									 */

									void changeLanguage(std::size_t nextLanguageIndex);


									void nextLanguage();


									/// Returns the number of available languages.

									std::size_t getLanguageCount() const;


									/// Returns the index of the current language.

									std::size_t getCurrentLanguageIndex() const;


									void openMenu(Menu* menu, int selectedItemIndex);

									void closeCurrentMenu();

									void selectMenuItem(int index, bool tween);

									void selectNextMenuItem();

									void selectPreviousMenuItem();

									void activateMenuItem();

									void activateLastMenuItem();


									void toggleFullscreen();

									void toggleVSync();

									void setUpdateRate(double frequency);


									void disableNonSystemControls();


									/**

									 * Changes the game state.

									 *

									 * @param state New game state.

									 */

									void changeState(GameState* state);


									const EventDispatcher* getEventDispatcher() const;

									EventDispatcher* getEventDispatcher();


									const Animator* getAnimator() const;

									Animator* getAnimator();


									void fadeIn(float duration, const Vector3& color, std::function<void()> callback);

									void fadeOut(float duration, const Vector3& color, std::function<void()> callback);

									void stopFade();


									void selectTool(int toolIndex);


								private:

									virtual void setup();

									virtual void input();

									virtual void update(float t, float dt);

									virtual void render();

									virtual void exit();

									virtual void handleEvent(const WindowResizedEvent& event);

									virtual void handleEvent(const GamepadConnectedEvent& event);

									virtual void handleEvent(const GamepadDisconnectedEvent& event);

									virtual void handleEvent(const ScheduledFunctionEvent& event);


									void setupDebugging();

									void setupLocalization();

									void setupWindow();

									void setupGraphics();

									void setupUI();

									void setupControls();

									void setupGameplay();


									void resetSettings();

									void loadSettings();

									void saveSettings();

									void loadStrings();

									void loadFonts();

									void loadControlProfile(const std::string& profileName);

									void saveControlProfile(const std::string& profileName);

									std::array<std::string, 3> getInputMappingStrings(const InputMapping* mapping);

									void remapControl(Control* control);

									void resetControls();

									// Callback for the input mapper

									void inputMapped(const InputMapping& mapping);


									void resizeUI(int w, int h);

									void restringUI();

									void restringControlMenuItem(MenuItem* item, const std::string& name);

									void resizeRenderTargets();


									void setTimeOfDay(float time);

									void queueScreenshot();

									void screenshot();


									// State functions

									void enterLanguageSelectState();

									void exitLanguageSelectState();

									void enterSplashState();

									void exitSplashState();

									void enterLoadingState();

									void exitLoadingState();

									void enterTitleState();

									void exitTitleState();

									void enterPlayState();

									void exitPlayState();


									void languageSelected();

									void skipSplash();


									void togglePause();


									void continueGame();

									void newGame();

									void returnToMainMenu();


									void interpretCommands();


								public:

									EntityID createInstance();

									EntityID createNamedInstance(const std::string& instanceName);

									EntityID createInstanceOf(const std::string& templateName);

									EntityID createNamedInstanceOf(const std::string& templateName, const std::string& instanceName);

									void selectInstance(EntityID entity);

									void selectNamedInstance(const std::string& instanceName);


									void destroyInstance(EntityID entity);

									void addComponent(EntityID entity, ComponentBase* component);

									void removeComponent(EntityID entity, ComponentType type);

									void setTranslation(EntityID entity, const Vector3& translation);

									void setRotation(EntityID entity, const Quaternion& rotation);

									void setScale(EntityID entity, const Vector3& scale);

									void setTerrainPatchPosition(EntityID entity, const std::tuple<int, int>& position);


									void boxSelect(float x, float y, float w, float h);


									template <typename T>

									bool readSetting(const std::string& name, T* value) const;


								public:

									// Game states

									StateMachine::State languageSelectState;

									StateMachine::State splashState;

									StateMachine::State loadingState;

									StateMachine::State titleState;

									StateMachine::State playState;


									GameState* currentState;

									SandboxState* sandboxState;


									// Paths

									std::string dataPath;

									std::string configPath;

									std::string controlsPath;


									// Settings

									bool firstRun;

									StringTable* settingsTable;

									StringTableIndex settingsTableIndex;


									// Localization

									StringTable* stringTable;

									StringTableIndex stringTableIndex;

									std::size_t languageCount;

									std::size_t currentLanguageIndex;


									// Window management

									Window* window;

									int w, h;

									float dpi;

									float fontSizePX;


									// Input

									Mouse* mouse;

									Keyboard* keyboard;


									// Master control set

									ControlSet controls;


									// System control set

									ControlSet systemControls;

									Control exitControl;

									Control toggleFullscreenControl;

									Control takeScreenshotControl;


									// Menu control set

									ControlSet menuControls;

									Control menuUpControl;

									Control menuDownControl;

									Control menuLeftControl;

									Control menuRightControl;

									Control menuActivateControl;

									Control menuBackControl;


									// Camera control set

									ControlSet cameraControls;

									Control moveForwardControl;

									Control moveLeftControl;

									Control moveBackControl;

									Control moveRightControl;

									Control zoomInControl;

									Control zoomOutControl;

									Control orbitCCWControl;

									Control orbitCWControl;

									Control adjustCameraControl;

									Control dragCameraControl;

									Control pauseControl;


									// Tool control set

									ControlSet toolControls;

									Control changeToolControl;

									Control useToolControl;


									// Editor control set

									ControlSet editorControls;

									Control toggleEditModeControl;


									// Map of control names

									std::map<std::string, Control*> controlNameMap;


									// Input mapper

									InputMapper* inputMapper;


									// Logic

									float time;

									float timestep;


									// UI

									Font* debugFont;

									Font* menuFont;

									std::vector<Font*> languageSelectionFonts;

									BillboardBatch* uiBatch;

									UIBatcher* uiBatcher;

									UIContainer* uiRootElement;

									UIImage* splashBackgroundImage;

									UIImage* splashImage;

									UIContainer* hudContainer;

									UIImage* toolIndicatorBGImage;

									UIImage* toolIndicatorIconImage;

									Rect* toolIndicatorsBounds;

									UIImage* toolIconBrushImage;

									UIImage* toolIconLensImage;

									UIImage* toolIconForcepsImage;

									UIImage* toolIconSpadeImage;

									UIImage* toolIconCameraImage;

									UIImage* toolIconMicrochipImage;

									UIImage* toolIconTestTubeImage;

									UIContainer* buttonContainer;

									UIImage* playButtonBGImage;

									UIImage* fastForwardButtonBGImage;

									UIImage* pauseButtonBGImage;

									UIImage* playButtonImage;

									UIImage* fastForwardButtonImage;

									UIImage* pauseButtonImage;

									UIContainer* radialMenuContainer;

									UIImage* radialMenuBackgroundImage;

									UIImage* radialMenuImage;

									UIImage* radialMenuSelectorImage;

									UIImage* blackoutImage;

									UIImage* languageSelectBGImage;

									UIImage* cameraFlashImage;

									UIContainer* antTag;

									UIContainer* antLabelContainer;

									UILabel* fpsLabel;

									UILabel* antLabel;

									UIImage* antLabelTL; // Top-left

									UIImage* antLabelTR; // Top-right

									UIImage* antLabelBL; // Bottom-left

									UIImage* antLabelBR; // Bottom-right

									UIImage* antLabelCC; // Center-center

									UIImage* antLabelCT; // Center-top

									UIImage* antLabelCB; // Center-bottom

									UIImage* antLabelCL; // Center-left

									UIImage* antLabelCR; // Center-right

									UIImage* antLabelPinHole;

									UIImage* antPin;


									UIImage* boxSelectionImageBackground;

									UIImage* boxSelectionImageTop;

									UIImage* boxSelectionImageBottom;

									UIImage* boxSelectionImageLeft;

									UIImage* boxSelectionImageRight;

									UIContainer* boxSelectionContainer;

									float boxSelectionBorderWidth;


									UIImage* cameraGridY0Image;

									UIImage* cameraGridY1Image;

									UIImage* cameraGridX0Image;

									UIImage* cameraGridX1Image;

									UIImage* cameraReticleImage;

									UIContainer* cameraGridContainer;

									Vector4 cameraGridColor;

									Vector4 cameraReticleColor;


									// Menu selection

									UIImage* menuSelectorImage;

									Menu* currentMenu;

									Menu* previousMenu;

									MenuItem* currentMenuItem;

									MenuItem* previousMenuItem;

									int menuItemIndex;

									Vector4 standardMenuActiveColor;

									Vector4 standardMenuInactiveColor;

									Vector4 languageMenuActiveColor;

									Vector4 languageMenuInactiveColor;

									Vector4 menuItemActiveColor;

									Vector4 menuItemInactiveColor;


									// Main menu

									Menu* mainMenu;

									MenuItem* mainMenuContinueItem;

									MenuItem* mainMenuNewGameItem;

									MenuItem* mainMenuColoniesItem;

									MenuItem* mainMenuSettingsItem;

									MenuItem* mainMenuQuitItem;


									// Settings menu

									Menu* settingsMenu;

									MenuItem* settingsMenuControlsItem;

									MenuItem* settingsMenuFullscreenItem;

									MenuItem* settingsMenuVSyncItem;

									MenuItem* settingsMenuLanguageItem;

									MenuItem* settingsMenuBackItem;


									// Controls menu

									Menu* controlsMenu;

									MenuItem* controlsMenuMoveForwardItem;

									MenuItem* controlsMenuMoveLeftItem;

									MenuItem* controlsMenuMoveBackItem;

									MenuItem* controlsMenuMoveRightItem;

									MenuItem* controlsMenuChangeToolItem;

									MenuItem* controlsMenuUseToolItem;

									MenuItem* controlsMenuAdjustCameraItem;

									MenuItem* controlsMenuPauseItem;

									MenuItem* controlsMenuToggleFullscreenItem;

									MenuItem* controlsMenuTakeScreenshotItem;

									MenuItem* controlsMenuResetToDefaultItem;

									MenuItem* controlsMenuBackItem;


									// Pause menu

									Menu* pauseMenu;

									MenuItem* pauseMenuResumeItem;

									MenuItem* pauseMenuSettingsItem;

									MenuItem* pauseMenuMainMenuItem;

									MenuItem* pauseMenuQuitItem;


									Menu* languageMenu;

									std::vector<MenuItem*> languageMenuItems;


									// Rendering

									Renderer renderer;

									RenderTarget defaultRenderTarget;

									ClearRenderPass* clearPass;

									ClearRenderPass* clearSilhouettePass;

									SkyRenderPass* skyPass;

									UIRenderPass* uiPass;

									Compositor uiCompositor;

									Compositor defaultCompositor;

									int shadowMapResolution;

									GLuint shadowMapDepthTextureID;

									GLuint shadowMapFramebuffer;

									RenderTarget shadowMapRenderTarget;

									ShadowMapRenderPass* shadowMapPass;

									Compositor shadowMapCompositor;

									Texture2D shadowMapDepthTexture;

									LightingRenderPass* lightingPass;

									SilhouetteRenderPass* silhouettePass;

									FinalRenderPass* finalPass;

									RenderTarget silhouetteRenderTarget;


									// Scene

									Scene* worldScene;

									Scene* uiScene;

									DirectionalLight sunlight;

									Camera camera;

									Camera sunlightCamera;

									Camera uiCamera;


									// Animation

									Animator animator;


									Animation<float> antHillZoomAnimation;

									AnimationClip<float> antHillZoomClip;


									Animation<float> menuFadeAnimation;

									AnimationClip<float> menuFadeInClip;

									AnimationClip<float> menuFadeOutClip;


									Animation<float> splashFadeInAnimation;

									Animation<float> splashFadeOutAnimation;

									AnimationClip<float> splashFadeInClip;

									AnimationClip<float> splashFadeOutClip;

									Animation<float> fadeInAnimation;

									Animation<float> fadeOutAnimation;

									AnimationClip<float> fadeInClip;

									AnimationClip<float> fadeOutClip;

									std::function<void()> fadeInEndCallback;

									std::function<void()> fadeOutEndCallback;

									Animation<float> cameraFlashAnimation;

									AnimationClip<float> cameraFlashClip;

									Animation<float> menuSelectorSlideAnimation;

									AnimationClip<float> menuSelectorSlideClip;

									Animation<Vector4> menuItemSelectAnimation;

									AnimationClip<Vector4> menuItemSelectClip;

									Animation<Vector4> menuItemDeselectAnimation;

									AnimationClip<Vector4> menuItemDeselectClip;


									// Assets

									ResourceManager* resourceManager;

									Texture2D* splashTexture;

									Texture2D* hudSpriteSheetTexture;

									TextureAtlas hudTextureAtlas;

									Material* smokeMaterial;

									Model* lensModel;

									Model* forcepsModel;

									Model* brushModel;


									// Game

									CameraRig* cameraRig;

									OrbitCam* orbitCam;

									FreeCam* freeCam;

									Tool* currentTool;

									Lens* lens;

									Forceps* forceps;

									Brush* brush;


									// ECS

									EntityManager* entityManager;

									ComponentManager* componentManager;

									SystemManager* systemManager;

									SoundSystem* soundSystem;

									CollisionSystem* collisionSystem;

									CameraSystem* cameraSystem;

									RenderSystem* renderSystem;

									ToolSystem* toolSystem;

									BehaviorSystem* behaviorSystem;

									SteeringSystem* steeringSystem;

									LocomotionSystem* locomotionSystem;

									ParticleSystem* particleSystem;

									TerrainSystem* terrainSystem;


									bool screenshotQueued;

									bool paused;


									// Settings

									std::string language;

									Vector2 windowedResolution;

									Vector2 fullscreenResolution;

									bool fullscreen;

									bool vsync;

									float fontSizePT;

									std::string controlProfileName;

									bool toggleFullscreenDisabled;


									// Debugging

									Logger* logger;

									std::ofstream logFileStream;

									CommandInterpreter* cli;


								private:

									static void saveScreenshot(const std::string& filename, unsigned int width, unsigned int height, unsigned char* pixels);

								};


								inline const EventDispatcher* Game::getEventDispatcher() const

								{

									return &eventDispatcher;

								}


								inline EventDispatcher* Game::getEventDispatcher()

								{

									return &eventDispatcher;

								}


								inline const Animator* Game::getAnimator() const

								{

									return &animator;

								}


								inline Animator* Game::getAnimator()

								{

									return &animator;

								}


								inline std::size_t Game::getLanguageCount() const

								{

									return languageCount;

								}


								inline std::size_t Game::getCurrentLanguageIndex() const

								{

									return currentLanguageIndex;

								}


								#endif // GAME_HPP