PlatformExtension.h

/*
 * GDevelop Core
 * Copyright 2008-2016 Florian Rival ([email protected]). All rights
 * reserved. Copyright 2016 Victor Levasseur ([email protected]) This
 * project is released under the MIT License.
 */
 
#pragma once
#include <map>
#include <memory>
#include <vector>
 
#include "GDCore/CommonTools.h"
#include "GDCore/Extensions/Metadata/BehaviorMetadata.h"
#include "GDCore/Extensions/Metadata/DependencyMetadata.h"
#include "GDCore/Extensions/Metadata/EffectMetadata.h"
#include "GDCore/Extensions/Metadata/EventMetadata.h"
#include "GDCore/Extensions/Metadata/InstructionOrExpressionGroupMetadata.h"
#include "GDCore/Extensions/Metadata/ObjectMetadata.h"
#include "GDCore/Project/PropertyDescriptor.h"
#include "GDCore/String.h"
#include "GDCore/Tools/VersionPriv.h"
 
namespace gd {
class Instruction;
class InstructionMetadata;
class MultipleInstructionMetadata;
class ExpressionMetadata;
class ObjectMetadata;
class BehaviorMetadata;
class EffectMetadata;
class DependencyMetadata;
class BaseEvent;
class EventMetadata;
class EventCodeGenerator;
class ArbitraryResourceWorker;
class BehaviorsSharedData;
class Behavior;
class Object;
class ObjectConfiguration;
}  // namespace gd
 
typedef std::function<std::unique_ptr<gd::ObjectConfiguration>()> CreateFunPtr;
 
namespace gd {
 
class GD_CORE_API CompilationInfo {
 public:
  CompilationInfo() {};
  virtual ~CompilationInfo() {};
 
  bool informationCompleted = false;
 
  bool runtimeOnly = false;  
 
#if defined(__GNUC__)
  int gccMajorVersion = 0;
  int gccMinorVersion = 0;
  int gccPatchLevel = 0;
#endif
 
  int sfmlMajorVersion = 0;
  int sfmlMinorVersion = 0;
 
  gd::String gdCoreVersion;
  int sizeOfpInt = 0;
};
 
struct GD_CORE_API DuplicatedInstructionOptions {
  bool unscoped;
};
 
class GD_CORE_API PlatformExtension {
 public:
  CompilationInfo compilationInfo;
 
  PlatformExtension();
  virtual ~PlatformExtension();
 
 
  PlatformExtension& SetExtensionInformation(const gd::String& name_,
                                             const gd::String& fullname_,
                                             const gd::String& description_,
                                             const gd::String& author_,
                                             const gd::String& license_);
 
  PlatformExtension& SetIconUrl(const gd::String& iconUrl_) {
    iconUrl = iconUrl_;
    return *this;
  }
 
  PlatformExtension& SetCategory(const gd::String& category_) {
    category = category_;
    return *this;
  }
 
  PlatformExtension& SetExtensionHelpPath(const gd::String& helpPath_) {
    helpPath = helpPath_;
    return *this;
  }
 
  void MarkAsDeprecated() { deprecated = true; }
 
 
 
  gd::InstructionMetadata& AddCondition(const gd::String& name_,
                                        const gd::String& fullname_,
                                        const gd::String& description_,
                                        const gd::String& sentence_,
                                        const gd::String& group_,
                                        const gd::String& icon_,
                                        const gd::String& smallicon_);
 
  gd::InstructionMetadata& AddAction(const gd::String& name_,
                                     const gd::String& fullname_,
                                     const gd::String& description_,
                                     const gd::String& sentence_,
                                     const gd::String& group_,
                                     const gd::String& icon_,
                                     const gd::String& smallicon_);
  gd::ExpressionMetadata& AddExpression(const gd::String& name_,
                                        const gd::String& fullname_,
                                        const gd::String& description_,
                                        const gd::String& group_,
                                        const gd::String& smallicon_);
  gd::ExpressionMetadata& AddStrExpression(const gd::String& name_,
                                           const gd::String& fullname_,
                                           const gd::String& description_,
                                           const gd::String& group_,
                                           const gd::String& smallicon_);
 
  gd::MultipleInstructionMetadata AddExpressionAndCondition(
      const gd::String& type,
      const gd::String& name,
      const gd::String& fullname,
      const gd::String& description,
      const gd::String& sentenceName,
      const gd::String& group,
      const gd::String& icon);
 
  gd::MultipleInstructionMetadata AddExpressionAndConditionAndAction(
      const gd::String& type,
      const gd::String& name,
      const gd::String& fullname,
      const gd::String& description,
      const gd::String& sentenceName,
      const gd::String& group,
      const gd::String& icon);
 
  gd::DependencyMetadata& AddDependency();
 
  template <class T>
  gd::ObjectMetadata& AddObject(const gd::String& name_,
                                const gd::String& fullname_,
                                const gd::String& description_,
                                const gd::String& icon_);
 
  gd::ObjectMetadata& AddObject(
      const gd::String& name_,
      const gd::String& fullname_,
      const gd::String& description_,
      const gd::String& icon_,
      std::shared_ptr<gd::ObjectConfiguration> instance);
 
  gd::ObjectMetadata& AddEventsBasedObject(const gd::String& name_,
                                           const gd::String& fullname_,
                                           const gd::String& description_,
                                           const gd::String& icon_);
 
  gd::BehaviorMetadata& AddBehavior(
      const gd::String& name_,
      const gd::String& fullname_,
      const gd::String& defaultName_,
      const gd::String& description_,
      const gd::String& group_,
      const gd::String& icon_,
      const gd::String& className_,
      std::shared_ptr<gd::Behavior> instance,
      std::shared_ptr<gd::BehaviorsSharedData> sharedDatasInstance);
 
  gd::EffectMetadata& AddEffect(const gd::String& name_);
 
  gd::EventMetadata& AddEvent(const gd::String& name_,
                              const gd::String& fullname_,
                              const gd::String& description_,
                              const gd::String& group_,
                              const gd::String& smallicon_,
                              std::shared_ptr<gd::BaseEvent> instance);
 
  gd::InstructionMetadata& AddDuplicatedAction(
      const gd::String& newActionName, const gd::String& copiedActionName);
  gd::InstructionMetadata& AddDuplicatedCondition(
      const gd::String& newConditionName,
      const gd::String& copiedConditionName,
      gd::DuplicatedInstructionOptions options = {.unscoped = false});
  gd::ExpressionMetadata& AddDuplicatedExpression(
      const gd::String& newExpressionName,
      const gd::String& copiedExpressionName);
  gd::ExpressionMetadata& AddDuplicatedStrExpression(
      const gd::String& newExpressionName,
      const gd::String& copiedExpressionName);
 
  gd::PropertyDescriptor& RegisterProperty(const gd::String& name) {
    return extensionPropertiesMetadata[name];
  };
 
  InstructionOrExpressionGroupMetadata& AddInstructionOrExpressionGroupMetadata(
      const gd::String& name) {
    return instructionOrExpressionGroupMetadata[name];
  }
 
  void StripUnimplementedInstructionsAndExpressions();
 
 
  const gd::String& GetFullName() const { return fullname; }
 
  const gd::String& GetName() const { return name; }
 
  const gd::String& GetCategory() const { return category; }
 
  const gd::String& GetDescription() const { return informations; }
 
  const gd::String& GetAuthor() const { return author; }
 
  const gd::String& GetLicense() const { return license; }
 
  const gd::String& GetHelpPath() const { return helpPath; }
 
  const gd::String& GetIconUrl() const { return iconUrl; }
 
  const std::vector<gd::String>& GetTags() const { return tags; }
 
  PlatformExtension& SetTags(const gd::String& csvTags) {
    tags.clear();
    tags = csvTags.Split(',');
    for (size_t i = 0; i < tags.size(); i++) {
      tags[i] = tags[i].Trim().LowerCase();
    }
    return *this;
  }
 
  PlatformExtension& AddTag(const gd::String& tag) {
    tags.push_back(tag);
    return *this;
  }
 
  bool IsDeprecated() const { return deprecated; }
 
  bool IsBuiltin() const;
 
  const gd::String& GetNameSpace() { return nameSpace; };
 
  std::vector<gd::String> GetExtensionObjectsTypes() const;
 
  std::vector<gd::String> GetBehaviorsTypes() const;
 
  CreateFunPtr GetObjectCreationFunctionPtr(const gd::String& objectType) const;
 
  std::vector<gd::String> GetExtensionEffectTypes() const;
 
  std::shared_ptr<gd::BaseEvent> CreateEvent(const gd::String& eventType) const;
  gd::Behavior* GetBehavior(const gd::String& behaviorType) const;
 
  gd::BehaviorsSharedData* GetBehaviorSharedDatas(
      const gd::String& behaviorType) const;
 
  ObjectMetadata& GetObjectMetadata(const gd::String& objectType);
 
  BehaviorMetadata& GetBehaviorMetadata(const gd::String& behaviorType);
 
  bool HasBehavior(const gd::String& behaviorType) const;
 
  EffectMetadata& GetEffectMetadata(const gd::String& effectName);
 
  std::map<gd::String, gd::EventMetadata>& GetAllEvents();
 
  std::map<gd::String, gd::InstructionMetadata>& GetAllActions();
 
  std::map<gd::String, gd::InstructionMetadata>& GetAllConditions();
 
  std::map<gd::String, gd::ExpressionMetadata>& GetAllExpressions();
 
  std::map<gd::String, gd::ExpressionMetadata>& GetAllStrExpressions();
 
  std::vector<gd::DependencyMetadata>& GetAllDependencies();
 
  std::map<gd::String, gd::InstructionMetadata>& GetAllActionsForObject(
      gd::String objectType);
 
  std::map<gd::String, gd::InstructionMetadata>& GetAllConditionsForObject(
      gd::String objectType);
 
  std::map<gd::String, gd::ExpressionMetadata>& GetAllExpressionsForObject(
      gd::String objectType);
 
  std::map<gd::String, gd::ExpressionMetadata>& GetAllStrExpressionsForObject(
      gd::String objectType);
 
  std::map<gd::String, gd::InstructionMetadata>& GetAllActionsForBehavior(
      gd::String autoType);
 
  std::map<gd::String, gd::InstructionMetadata>& GetAllConditionsForBehavior(
      gd::String autoType);
 
  std::map<gd::String, gd::ExpressionMetadata>& GetAllExpressionsForBehavior(
      gd::String autoType);
 
  std::map<gd::String, gd::ExpressionMetadata>& GetAllStrExpressionsForBehavior(
      gd::String autoType);
 
  std::map<gd::String, gd::PropertyDescriptor>& GetAllProperties() {
    return extensionPropertiesMetadata;
  }
 
  const std::map<gd::String, InstructionOrExpressionGroupMetadata>&
  GetAllInstructionOrExpressionGroupMetadata() const {
    return instructionOrExpressionGroupMetadata;
  }
 
  static std::vector<gd::String> GetBuiltinExtensionsNames();
 
  static gd::String GetNamespaceSeparator() { return "::"; }
 
  static gd::String GetEventsFunctionFullType(const gd::String& extensionName,
                                              const gd::String& functionName);
 
  static gd::String GetBehaviorEventsFunctionFullType(
      const gd::String& extensionName,
      const gd::String& behaviorName,
      const gd::String& functionName);
 
  static gd::String GetBehaviorFullType(const gd::String& extensionName,
                                        const gd::String& behaviorName);
 
  static gd::String GetObjectEventsFunctionFullType(
      const gd::String& extensionName,
      const gd::String& objectName,
      const gd::String& functionName);
 
  static gd::String GetObjectFullType(const gd::String& extensionName,
                                      const gd::String& objectName);
 
  static gd::String GetExtensionFromFullObjectType(const gd::String& type);
 
  static gd::String GetObjectNameFromFullObjectType(const gd::String& type);
 
 private:
  void SetNameSpace(gd::String nameSpace_);
 
  gd::String name;  
  gd::String
      nameSpace;  
  gd::String fullname;      
  gd::String informations;  
  gd::String category;
  gd::String author;   
  gd::String license;  
  bool deprecated;     
  gd::String helpPath;  
  gd::String iconUrl;   
  std::vector<gd::String> tags;
 
  std::map<gd::String, gd::ObjectMetadata> objectsInfos;
  std::map<gd::String, gd::BehaviorMetadata> behaviorsInfo;
  std::map<gd::String, gd::EffectMetadata> effectsMetadata;
  std::map<gd::String, gd::InstructionMetadata> conditionsInfos;
  std::map<gd::String, gd::InstructionMetadata> actionsInfos;
  std::map<gd::String, gd::ExpressionMetadata> expressionsInfos;
  std::map<gd::String, gd::ExpressionMetadata> strExpressionsInfos;
  std::vector<gd::DependencyMetadata> extensionDependenciesMetadata;
  std::map<gd::String, gd::EventMetadata> eventsInfos;
  std::map<gd::String, gd::PropertyDescriptor> extensionPropertiesMetadata;
  std::map<gd::String, InstructionOrExpressionGroupMetadata>
      instructionOrExpressionGroupMetadata;
 
  ObjectMetadata badObjectMetadata;
  BehaviorMetadata badBehaviorMetadata;
  EffectMetadata badEffectMetadata;
  static std::map<gd::String, gd::InstructionMetadata>
      badConditionsMetadata;  
  static std::map<gd::String, gd::InstructionMetadata>
      badActionsMetadata;  
  static std::map<gd::String, gd::ExpressionMetadata>
      badExpressionsMetadata;  
};
 
}  // namespace gd
 
#define GD_COMPLETE_EXTENSION_COMPILATION_INFORMATION() \
  compilationInfo.runtimeOnly = false;                  \
  compilationInfo.sfmlMajorVersion = 2;                 \
  compilationInfo.sfmlMinorVersion = 0;                 \
  compilationInfo.gdCoreVersion = GD_VERSION_STRING;    \
  compilationInfo.sizeOfpInt = sizeof(int*);            \
  compilationInfo.gccMajorVersion = __GNUC__;           \
  compilationInfo.gccMinorVersion = __GNUC_MINOR__;     \
  compilationInfo.gccPatchLevel = __GNUC_PATCHLEVEL__;  \
  compilationInfo.informationCompleted = true;
 
#include "GDCore/Extensions/PlatformExtension.inl"