Project.h

/*
 * GDevelop Core
 * Copyright 2008-2016 Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
 
#pragma once
 
#include <memory>
#include <vector>
 
#include "GDCore/Events/CodeGeneration/DiagnosticReport.h"
#include "GDCore/Project/ExtensionProperties.h"
#include "GDCore/Project/LoadingScreen.h"
#include "GDCore/Project/ObjectGroupsContainer.h"
#include "GDCore/Project/ObjectsContainer.h"
#include "GDCore/Project/PlatformSpecificAssets.h"
#include "GDCore/Project/ResourcesContainer.h"
#include "GDCore/Project/VariablesContainer.h"
#include "GDCore/Project/Watermark.h"
#include "GDCore/Project/MemoryTrackedRegistry.h"
#include "GDCore/String.h"
namespace gd {
class Platform;
class Layout;
class ExternalEvents;
class ResourcesContainer;
class ExternalLayout;
class EventsFunctionsExtension;
class EventsBasedObject;
class EventsBasedBehavior;
class Object;
class ObjectConfiguration;
class VariablesContainer;
class ArbitraryResourceWorker;
class Behavior;
class BehaviorsSharedData;
class BaseEvent;
class SerializerElement;
}  // namespace gd
#undef GetObject  // Disable an annoying macro
#undef CreateEvent
 
namespace gd {
class GD_CORE_API Project {
 public:
  Project();
  Project(const Project&);
  virtual ~Project();
  Project& operator=(const Project& rhs);
 
 
  void SetName(const gd::String& name_) { name = name_; };
 
  const gd::String& GetName() const { return name; }
 
  const std::vector<gd::String>& GetCategories() const { return categories; };
 
  std::vector<gd::String>& GetCategories() { return categories; };
 
  void SetDescription(const gd::String& description_) {
    description = description_;
  };
 
  const gd::String& GetDescription() const { return description; }
 
  void SetVersion(const gd::String& version_) { version = version_; };
 
  const gd::String& GetVersion() const { return version; }
 
  void SetAuthor(const gd::String& author_) { author = author_; };
 
  const gd::String& GetAuthor() const { return author; }
 
  const std::vector<gd::String>& GetAuthorIds() const { return authorIds; };
 
  std::vector<gd::String>& GetAuthorIds() { return authorIds; };
 
  const std::vector<gd::String>& GetAuthorUsernames() const {
    return authorUsernames;
  };
 
  std::vector<gd::String>& GetAuthorUsernames() { return authorUsernames; };
 
  void SetPlayableWithKeyboard(bool playable = true) {
    isPlayableWithKeyboard = playable;
  }
 
  bool IsPlayableWithKeyboard() const { return isPlayableWithKeyboard; }
 
  void SetPlayableWithGamepad(bool playable = true) {
    isPlayableWithGamepad = playable;
  }
 
  bool IsPlayableWithGamepad() const { return isPlayableWithGamepad; }
 
  void SetPlayableWithMobile(bool playable = true) {
    isPlayableWithMobile = playable;
  }
 
  bool IsPlayableWithMobile() const { return isPlayableWithMobile; }
 
  void SetPackageName(const gd::String& packageName_) {
    packageName = packageName_;
  };
 
  const gd::String& GetPackageName() const { return packageName; }
 
  void SetTemplateSlug(const gd::String& templateSlug_) {
    templateSlug = templateSlug_;
  };
 
  const gd::String& GetTemplateSlug() const { return templateSlug; }
 
  void SetOrientation(const gd::String& orientation_) {
    orientation = orientation_;
  };
 
  const gd::String& GetOrientation() const { return orientation; }
 
  void SetProjectFile(const gd::String& file) { projectFile = file; }
 
  const gd::String& GetProjectFile() const { return projectFile; }
 
  void SetFolderProject(bool enable = true) { folderProject = enable; }
 
  bool IsFolderProject() const { return folderProject; }
 
  void SetLastCompilationDirectory(const gd::String& dir) {
    latestCompilationDirectory = dir;
  }
 
  const gd::String& GetLastCompilationDirectory() const {
    return latestCompilationDirectory;
  }
 
  gd::PlatformSpecificAssets& GetPlatformSpecificAssets() {
    return platformSpecificAssets;
  }
 
  const gd::PlatformSpecificAssets& GetPlatformSpecificAssets() const {
    return platformSpecificAssets;
  }
 
  gd::LoadingScreen& GetLoadingScreen() { return loadingScreen; }
 
  const gd::LoadingScreen& GetLoadingScreen() const { return loadingScreen; }
 
  gd::Watermark& GetWatermark() { return watermark; }
 
  const gd::Watermark& GetWatermark() const { return watermark; }
 
  void SetGameResolutionSize(unsigned int width, unsigned int height) {
    windowWidth = width;
    windowHeight = height;
  }
 
  unsigned int GetGameResolutionWidth() const { return windowWidth; }
 
  unsigned int GetGameResolutionHeight() const { return windowHeight; }
 
  bool GetAdaptGameResolutionAtRuntime() const {
    return adaptGameResolutionAtRuntime;
  }
 
  void SetAdaptGameResolutionAtRuntime(bool adaptGameResolutionAtRuntime_) {
    adaptGameResolutionAtRuntime = adaptGameResolutionAtRuntime_;
  }
 
  const gd::String& GetSizeOnStartupMode() const { return sizeOnStartupMode; }
 
  void SetSizeOnStartupMode(const gd::String& mode) {
    sizeOnStartupMode = mode;
  }
 
  void SetMaximumFPS(int maxFPS_) { maxFPS = maxFPS_; }
 
  int GetMaximumFPS() const { return maxFPS; }
 
  void SetMinimumFPS(unsigned int minFPS_) { minFPS = minFPS_; }
 
  unsigned int GetMinimumFPS() const { return minFPS; }
 
  bool IsVerticalSynchronizationEnabledByDefault() const {
    return verticalSync;
  }
 
  void SetVerticalSyncActivatedByDefault(bool enable) { verticalSync = enable; }
 
  const gd::String& GetScaleMode() const { return scaleMode; }
 
  void SetScaleMode(const gd::String& scaleMode_) { scaleMode = scaleMode_; }
 
  bool GetPixelsRounding() const { return pixelsRounding; }
 
  void SetPixelsRounding(bool enable) { pixelsRounding = enable; }
 
  const gd::String& GetAntialiasingMode() const { return antialiasingMode; }
 
  void SetAntialiasingMode(const gd::String& antialiasingMode_) {
    antialiasingMode = antialiasingMode_;
  }
 
  bool IsAntialisingEnabledOnMobile() const {
    return isAntialisingEnabledOnMobile;
  }
 
  void SetAntialisingEnabledOnMobile(bool enable) {
    isAntialisingEnabledOnMobile = enable;
  }
 
  bool GetUseDeprecatedZeroAsDefaultZOrder() const {
    return useDeprecatedZeroAsDefaultZOrder;
  }
 
  void SetUseDeprecatedZeroAsDefaultZOrder(bool enable) {
    useDeprecatedZeroAsDefaultZOrder = enable;
  }
 
  bool GetUseDeprecatedZeroAsDefaultStringVariable() const {
    return useDeprecatedZeroAsDefaultStringVariable;
  }
 
  void SetUseDeprecatedZeroAsDefaultStringVariable(bool enable) {
    useDeprecatedZeroAsDefaultStringVariable = enable;
  }
 
  void SetProjectUuid(const gd::String& projectUuid_) {
    projectUuid = projectUuid_;
  };
 
  const gd::String& GetProjectUuid() const { return projectUuid; }
 
  void ResetProjectUuid();
 
  gd::ExtensionProperties& GetExtensionProperties() {
    return extensionProperties;
  };
 
  const gd::ExtensionProperties& GetExtensionProperties() const {
    return extensionProperties;
  };
 
  const std::vector<Platform*>& GetUsedPlatforms() const { return platforms; };
 
  void AddPlatform(Platform& platform);
 
  bool RemovePlatform(const gd::String& platformName);
 
  Platform& GetCurrentPlatform() const;
 
  void SetCurrentPlatform(const gd::String& platformName);
 
  bool AreEffectsHiddenInEditor() const { return areEffectsHiddenInEditor; }
 
  void SetEffectsHiddenInEditor(bool enable = true) {
    areEffectsHiddenInEditor = enable;
  }
 
 
 
  std::unique_ptr<gd::Object> CreateObject(const gd::String& type,
                                           const gd::String& name) const;
 
  void EnsureObjectDefaultBehaviors(gd::Object& object) const;
 
  std::shared_ptr<gd::BaseEvent> CreateEvent(
      const gd::String& type, const gd::String& platformName = "");
 
 
  bool HasLayoutNamed(const gd::String& name) const;
 
  Layout& GetLayout(const gd::String& name);
 
  const Layout& GetLayout(const gd::String& name) const;
 
  Layout& GetLayout(std::size_t index);
 
  const Layout& GetLayout(std::size_t index) const;
 
  std::size_t GetLayoutPosition(const gd::String& name) const;
 
  void MoveLayout(std::size_t oldIndex, std::size_t newIndex);
 
  void SwapLayouts(std::size_t first, std::size_t second);
 
  std::size_t GetLayoutsCount() const;
 
  gd::Layout& InsertNewLayout(const gd::String& name, std::size_t position);
 
  gd::Layout& InsertLayout(const Layout& layout, std::size_t position);
 
  void RemoveLayout(const gd::String& name);
 
 
  void UnserializeFrom(const SerializerElement& element);
 
  void SerializeTo(SerializerElement& element) const;
 
  unsigned int GetLastSaveGDMajorVersion() { return gdMajorVersion; };
 
  unsigned int GetLastSaveGDMinorVersion() { return gdMinorVersion; };
 
  unsigned int GetLastSaveGDBuildVersion() { return gdBuildVersion; };
 
 
  bool HasExternalEventsNamed(const gd::String& name) const;
 
  ExternalEvents& GetExternalEvents(const gd::String& name);
 
  const ExternalEvents& GetExternalEvents(const gd::String& name) const;
 
  ExternalEvents& GetExternalEvents(std::size_t index);
 
  const ExternalEvents& GetExternalEvents(std::size_t index) const;
 
  std::size_t GetExternalEventsPosition(const gd::String& name) const;
 
  void MoveExternalEvents(std::size_t oldIndex, std::size_t newIndex);
 
  void SwapExternalEvents(std::size_t first, std::size_t second);
 
  std::size_t GetExternalEventsCount() const;
 
  ExternalEvents& InsertNewExternalEvents(const gd::String& name,
                                          std::size_t position);
 
  ExternalEvents& InsertExternalEvents(const ExternalEvents& externalEvents,
                                       std::size_t position);
 
  void RemoveExternalEvents(const gd::String& name);
 
 
  bool HasExternalLayoutNamed(const gd::String& name) const;
 
  ExternalLayout& GetExternalLayout(const gd::String& name);
 
  const ExternalLayout& GetExternalLayout(const gd::String& name) const;
 
  ExternalLayout& GetExternalLayout(std::size_t index);
 
  const ExternalLayout& GetExternalLayout(std::size_t index) const;
 
  std::size_t GetExternalLayoutPosition(const gd::String& name) const;
 
  void MoveExternalLayout(std::size_t oldIndex, std::size_t newIndex);
 
  void SwapExternalLayouts(std::size_t first, std::size_t second);
 
  std::size_t GetExternalLayoutsCount() const;
 
  gd::ExternalLayout& InsertNewExternalLayout(const gd::String& name,
                                              std::size_t position);
 
  gd::ExternalLayout& InsertExternalLayout(const ExternalLayout& externalLayout,
                                           std::size_t position);
 
  void RemoveExternalLayout(const gd::String& name);
 
  void SetFirstLayout(const gd::String& name) { firstLayout = name; }
 
  const gd::String& GetFirstLayout() { return firstLayout; }
 
 
 
  bool HasEventsFunctionsExtensionNamed(const gd::String& name) const;
 
  EventsFunctionsExtension& GetEventsFunctionsExtension(const gd::String& name);
 
  const EventsFunctionsExtension& GetEventsFunctionsExtension(
      const gd::String& name) const;
 
  EventsFunctionsExtension& GetEventsFunctionsExtension(std::size_t index);
 
  const EventsFunctionsExtension& GetEventsFunctionsExtension(
      std::size_t index) const;
 
  std::size_t GetEventsFunctionsExtensionPosition(const gd::String& name) const;
 
  void MoveEventsFunctionsExtension(std::size_t oldIndex, std::size_t newIndex);
 
  void SwapEventsFunctionsExtensions(std::size_t first, std::size_t second);
 
  std::size_t GetEventsFunctionsExtensionsCount() const;
 
  gd::EventsFunctionsExtension& InsertNewEventsFunctionsExtension(
      const gd::String& name, std::size_t position);
 
  gd::EventsFunctionsExtension& InsertEventsFunctionsExtension(
      const EventsFunctionsExtension& eventsFunctionExtension,
      std::size_t position);
 
  void UnserializeAndInsertExtensionsFrom(
      const gd::SerializerElement& eventsFunctionsExtensionsElement);
 
  void RemoveEventsFunctionsExtension(const gd::String& name);
 
  void ClearEventsFunctionsExtensions();
 
  bool HasEventsBasedObject(const gd::String& type) const;
 
  gd::EventsBasedObject& GetEventsBasedObject(const gd::String& type);
 
  const gd::EventsBasedObject& GetEventsBasedObject(
      const gd::String& type) const;
 
  bool HasEventsBasedBehavior(const gd::String& type) const;
 
  gd::EventsBasedBehavior& GetEventsBasedBehavior(const gd::String& type);
 
  const gd::EventsBasedBehavior& GetEventsBasedBehavior(
      const gd::String& type) const;
 
 
 
  const ResourcesContainer& GetResourcesManager() const {
    return resourcesContainer;
  }
 
  ResourcesContainer& GetResourcesManager() { return resourcesContainer; }
 
  void SetSceneResourcesPreloading(gd::String sceneResourcesPreloading_) {
    sceneResourcesPreloading = sceneResourcesPreloading_;
  }
 
  const gd::String& GetSceneResourcesPreloading() const {
    return sceneResourcesPreloading;
  }
 
  void SetSceneResourcesUnloading(gd::String sceneResourcesUnloading_) {
    sceneResourcesUnloading = sceneResourcesUnloading_;
  }
 
  const gd::String& GetSceneResourcesUnloading() const {
    return sceneResourcesUnloading;
  }
 
 
  inline const gd::VariablesContainer& GetVariables() const {
    return variables;
  }
 
  inline gd::VariablesContainer& GetVariables() { return variables; }
 
 
 
  gd::ObjectsContainer& GetObjects() { return objectsContainer; }
 
  const gd::ObjectsContainer& GetObjects() const { return objectsContainer; }
 
 
  static bool IsNameSafe(const gd::String& name);
 
  static gd::String GetSafeName(const gd::String& name);
 
  gd::WholeProjectDiagnosticReport& GetWholeProjectDiagnosticReport() {
    return wholeProjectDiagnosticReport;
  }
 
  static std::vector<gd::String> GetUnserializingOrderExtensionNames(
      const gd::SerializerElement& eventsFunctionsExtensionsElement);
 
 private:
  void Init(const gd::Project& project);
 
  std::unique_ptr<gd::ObjectConfiguration> CreateObjectConfiguration(
      const gd::String& type) const;
 
  gd::MemoryTracked _memoryTracked{this, "Project"};
 
  gd::String name;         
  gd::String description;  
  gd::String version;      
  unsigned int windowWidth = 0;   
  unsigned int windowHeight = 0;  
  int maxFPS = 0;           
  unsigned int minFPS = 0;  
  bool verticalSync =
      false;  
  gd::String scaleMode;
  bool pixelsRounding = false;  
  bool adaptGameResolutionAtRuntime =
      true;  
  gd::String
      sizeOnStartupMode;  
  gd::String antialiasingMode;
  bool isAntialisingEnabledOnMobile = false;
  gd::String projectUuid;  
  bool useDeprecatedZeroAsDefaultZOrder =
      false;  
  bool useDeprecatedZeroAsDefaultStringVariable =
      false;  
  std::vector<std::unique_ptr<gd::Layout> > scenes;  
  gd::VariablesContainer variables;  
  gd::ObjectsContainer objectsContainer;
  std::vector<std::unique_ptr<gd::ExternalLayout> >
      externalLayouts;  
  std::vector<std::unique_ptr<gd::EventsFunctionsExtension> >
      eventsFunctionsExtensions;
  gd::ResourcesContainer
      resourcesContainer;  
  std::vector<gd::Platform*>
      platforms;  
  gd::String firstLayout;
  gd::String author;        
  std::vector<gd::String>
      authorIds;  
  std::vector<gd::String>
      authorUsernames;  
  std::vector<gd::String> categories;  
  bool isPlayableWithKeyboard =
      false;  
  bool isPlayableWithGamepad =
      false;  
  bool isPlayableWithMobile = false;  
  gd::String packageName;             
  gd::String templateSlug;  
  gd::String orientation;   
  bool folderProject =
      false;  
  gd::String
      projectFile;  
  gd::String latestCompilationDirectory;
  gd::Platform* currentPlatform =
      nullptr;  
  gd::PlatformSpecificAssets platformSpecificAssets;
  gd::LoadingScreen loadingScreen;
  gd::Watermark watermark;
  std::vector<std::unique_ptr<gd::ExternalEvents> >
      externalEvents;  
  ExtensionProperties
      extensionProperties;  
  gd::WholeProjectDiagnosticReport wholeProjectDiagnosticReport;
  gd::String sceneResourcesPreloading;  
  gd::String sceneResourcesUnloading;   
  mutable unsigned int gdMajorVersion =
      0;  
  mutable unsigned int gdMinorVersion =
      0;  
  mutable unsigned int gdBuildVersion =
      0;  
  bool areEffectsHiddenInEditor =
      false; 
};
 
}  // namespace gd