Object.h

/*
 * GDevelop Core
 * Copyright 2008-2016 Florian Rival ([email protected]). All rights
 * reserved. This project is released under the MIT License.
 */
#pragma once
 
#include <map>
#include <memory>
#include <vector>
 
#include "GDCore/Project/Behavior.h"
#include "GDCore/Project/BehaviorsContainer.h"
#include "GDCore/Project/EffectsContainer.h"
#include "GDCore/Project/ObjectConfiguration.h"
#include "GDCore/Project/VariablesContainer.h"
#include "GDCore/Project/MemoryTrackedRegistry.h"
#include "GDCore/String.h"
#include "GDCore/Tools/MakeUnique.h"
#include "GDCore/Vector2.h"
 
namespace gd {
class PropertyDescriptor;
class Project;
class Layout;
class ArbitraryResourceWorker;
class InitialInstance;
class SerializerElement;
class EffectsContainer;
}  // namespace gd
 
namespace gd {
 
class GD_CORE_API Object {
 public:
  Object(const gd::String& name,
         const gd::String& type,
         std::unique_ptr<gd::ObjectConfiguration> configuration);
 
  Object(const gd::String& name,
         const gd::String& type,
         gd::ObjectConfiguration* configuration);
 
  Object(const gd::Object& object) { Init(object); };
 
  Object& operator=(const gd::Object& object) {
    if ((this) != &object) Init(object);
    return *this;
  }
 
  virtual ~Object();
 
  virtual std::unique_ptr<gd::Object> Clone() const {
    return gd::make_unique<gd::Object>(*this);
  }
 
  void CopyWithoutConfiguration(const gd::Object& object);
 
  gd::ObjectConfiguration& GetConfiguration();
 
  const gd::ObjectConfiguration& GetConfiguration() const;
 
 
  void SetName(const gd::String& name_) { name = name_; };
 
  const gd::String& GetName() const { return name; };
 
  void SetAssetStoreId(const gd::String& assetStoreId_) {
    assetStoreId = assetStoreId_;
  };
 
  const gd::String& GetAssetStoreId() const { return assetStoreId; };
 
  void SetType(const gd::String& type_) { configuration->SetType(type_); }
 
  const gd::String& GetType() const { return configuration->GetType(); }
 
  void SetResourcesPreloading(gd::String resourcesPreloading_) {
    resourcesPreloading = resourcesPreloading_;
  }
 
  const gd::String& GetResourcesPreloading() const {
    return resourcesPreloading;
  }
 
 
 
  std::vector<gd::String> GetAllBehaviorNames() const;
 
  Behavior& GetBehavior(const gd::String& name);
 
  const Behavior& GetBehavior(const gd::String& name) const;
 
  bool HasBehaviorNamed(const gd::String& name) const;
 
  void RemoveBehavior(const gd::String& name);
 
  bool RenameBehavior(const gd::String& name, const gd::String& newName);
 
  gd::Behavior* AddNewBehavior(const gd::Project& project,
                               const gd::String& type,
                               const gd::String& name);
 
  const std::map<gd::String, std::unique_ptr<gd::Behavior>>&
  GetAllBehaviorContents() const {
    return behaviors.GetAllBehaviorContents();
  };
 
 
  const gd::VariablesContainer& GetVariables() const { return objectVariables; }
 
  gd::VariablesContainer& GetVariables() { return objectVariables; }
 
 
  const gd::EffectsContainer& GetEffects() const { return effectsContainer; }
 
  gd::EffectsContainer& GetEffects() { return effectsContainer; }
 
 
  void SerializeTo(SerializerElement& element) const;
 
  void UnserializeFrom(gd::Project& project, const SerializerElement& element);
 
  Object& ResetPersistentUuid();
 
  const gd::String& GetPersistentUuid() const;
 
 protected:
  gd::MemoryTracked _memoryTracked{this, "gdObject"};
 
  gd::String name;          
  gd::String assetStoreId;  
  std::unique_ptr<gd::ObjectConfiguration> configuration;
  gd::BehaviorsContainer
      behaviors; 
  gd::VariablesContainer
      objectVariables;  
  gd::EffectsContainer
      effectsContainer;  
  mutable gd::String persistentUuid;  
 
  gd::String resourcesPreloading = "with-scene";
 
  void Init(const gd::Object& object);
};
 
struct ObjectHasName : public std::binary_function<std::unique_ptr<gd::Object>,
                                                   gd::String,
                                                   bool> {
  bool operator()(const std::unique_ptr<gd::Object>& object,
                  const gd::String& name) const {
    return object->GetName() == name;
  }
};
 
}  // namespace gd