Allow to create variants of custom objects

Core/GDCore/IDE/EventsBasedObjectVariantHelper.cpp

@@ -0,0 +1,157 @@
+/*
+ * GDevelop Core
+ * Copyright 2008-2016 Florian Rival ([email protected]). All rights
+ * reserved. This project is released under the MIT License.
+ */
+#include "EventsBasedObjectVariantHelper.h"
+
+#include "GDCore/Project/EventsBasedObject.h"
+#include "GDCore/Project/InitialInstancesContainer.h"
+#include "GDCore/Project/Object.h"
+#include "GDCore/Project/ObjectGroup.h"
+#include "GDCore/Project/ObjectsContainer.h"
+#include "GDCore/Project/ObjectsContainersList.h"
+#include "GDCore/Project/Project.h"
+#include "GDCore/Project/Variable.h"
+#include "GDCore/Project/VariablesContainer.h"
+#include "GDCore/String.h"
+
+namespace gd {
+
+void EventsBasedObjectVariantHelper::ComplyVariantsToEventsBasedObject(
+    const gd::Project &project, gd::EventsBasedObject &eventsBasedObject) {
+  auto &defaultObjects = eventsBasedObject.GetDefaultVariant().GetObjects();
+
+  for (const auto &variant :
+       eventsBasedObject.GetVariants().GetInternalVector()) {
+    auto &objects = variant->GetObjects();
+
+    // Delete extra objects
+    for (auto it = objects.GetObjects().begin();
+         it != objects.GetObjects().end(); ++it) {
+      const auto &objectName = it->get()->GetName();
+      if (!defaultObjects.HasObjectNamed(objectName)) {
+        variant->GetInitialInstances().RemoveInitialInstancesOfObject(
+            objectName);
+        // Do it in last because it unalloc objectName.
+        objects.RemoveObject(objectName);
+        --it;
+      }
+    }
+    for (const auto &defaultObject : defaultObjects.GetObjects()) {
+      const auto &objectName = defaultObject->GetName();
+      const auto &defaultVariables = defaultObject->GetVariables();
+      const auto &defaultBehaviors = defaultObject->GetAllBehaviorContents();
+
+      // Copy missing objects
+      if (!objects.HasObjectNamed(objectName)) {
+        objects.InsertObject(*defaultObject,
+                             defaultObjects.GetObjectPosition(objectName));
+        objects.AddMissingObjectsInRootFolder();
+        continue;
+      }
+      // Change object types
+      auto &object = objects.GetObject(objectName);
+      if (object.GetType() != defaultObject->GetType()) {
+        // Keep a copy of the old object.
+        auto oldObject = objects.GetObject(objectName);
+        objects.RemoveObject(objectName);
+        objects.InsertObject(*defaultObject,
+                             defaultObjects.GetObjectPosition(objectName));
+        object.CopyWithoutConfiguration(oldObject);
+        objects.AddMissingObjectsInRootFolder();
+      }
+
+      // Copy missing behaviors
+      auto &behaviors = object.GetAllBehaviorContents();
+      for (const auto &pair : defaultBehaviors) {
+        const auto &behaviorName = pair.first;
+        const auto &defaultBehavior = pair.second;
+
+        if (object.HasBehaviorNamed(behaviorName) &&
+            object.GetBehavior(behaviorName).GetTypeName() !=
+                defaultBehavior->GetTypeName()) {
+          object.RemoveBehavior(behaviorName);
+        }
+        if (!object.HasBehaviorNamed(behaviorName)) {
+          auto *behavior = object.AddNewBehavior(
+              project, defaultBehavior->GetTypeName(), behaviorName);
+          gd::SerializerElement element;
+          defaultBehavior->SerializeTo(element);
+          behavior->UnserializeFrom(element);
+        }
+      }
+      // Delete extra behaviors
+      for (auto it = behaviors.begin(); it != behaviors.end(); ++it) {
+        const auto &behaviorName = it->first;
+        if (!defaultObject->HasBehaviorNamed(behaviorName)) {
+          object.RemoveBehavior(behaviorName);
+          --it;
+        }
+      }
+
+      // Sort and copy missing variables
+      auto &variables = object.GetVariables();
+      for (size_t defaultVariableIndex = 0;
+           defaultVariableIndex < defaultVariables.Count();
+           defaultVariableIndex++) {
+        const auto &variableName =
+            defaultVariables.GetNameAt(defaultVariableIndex);
+        const auto &defaultVariable =
+            defaultVariables.Get(defaultVariableIndex);
+
+        auto variableIndex = variables.GetPosition(variableName);
+        if (variableIndex == gd::String::npos) {
+          variables.Insert(variableName, defaultVariable, defaultVariableIndex);
+        } else {
+          variables.Move(variableIndex, defaultVariableIndex);
+        }
+        if (variables.Get(variableName).GetType() != defaultVariable.GetType()) {
+          variables.Remove(variableName);
+          variables.Insert(variableName, defaultVariable, defaultVariableIndex);
+        }
+      }
+      // Remove extra variables
+      auto variableToRemoveCount = variables.Count() - defaultVariables.Count();
+      for (size_t iteration = 0; iteration < variableToRemoveCount;
+           iteration++) {
+        variables.Remove(variables.GetNameAt(variables.Count() - 1));
+      }
+
+      // Remove extra instance variables
+      variant->GetInitialInstances().IterateOverInstances(
+          [&objectName,
+           &defaultVariables](gd::InitialInstance &initialInstance) {
+            if (initialInstance.GetObjectName() != objectName) {
+              return false;
+            }
+            auto &instanceVariables = initialInstance.GetVariables();
+            for (size_t instanceVariableIndex = 0;
+                 instanceVariableIndex < instanceVariables.Count();
+                 instanceVariableIndex++) {
+              const auto &variableName =
+                  defaultVariables.GetNameAt(instanceVariableIndex);
+
+              if (!defaultVariables.Has(variableName)) {
+                instanceVariables.Remove(variableName);
+              }
+            }
+            return false;
+          });
+    }
+    auto &defaultObjectGroups =
+        eventsBasedObject.GetDefaultVariant().GetObjects().GetObjectGroups();
+    auto &objectGroups = variant->GetObjects().GetObjectGroups();
+    auto objectGroupsCount = objectGroups.Count();
+    // Clear groups
+    for (size_t index = 0; index < objectGroupsCount; index++) {
+      objectGroups.Remove(objectGroups.Get(0).GetName());
+    }
+    // Copy groups
+    for (size_t index = 0; index < defaultObjectGroups.Count(); index++) {
+      objectGroups.Insert(defaultObjectGroups.Get(index), index);
+    }
+  }
+}
+
+} // namespace gd

Core/GDCore/IDE/EventsBasedObjectVariantHelper.h

@@ -0,0 +1,26 @@
+/*
+ * GDevelop Core
+ * Copyright 2008-2016 Florian Rival ([email protected]). All rights
+ * reserved. This project is released under the MIT License.
+ */
+#pragma once
+
+namespace gd {
+class EventsBasedObject;
+class Project;
+} // namespace gd
+
+namespace gd {
+
+class GD_CORE_API EventsBasedObjectVariantHelper {
+public:
+  /**
+   * @brief Apply the changes done on events-based object children to all its
+   * variants.
+   */
+  static void
+  ComplyVariantsToEventsBasedObject(const gd::Project &project,
+                                    gd::EventsBasedObject &eventsBasedObject);
+};
+
+} // namespace gd

Core/GDCore/IDE/ObjectAssetSerializer.cpp

@@ -17,6 +17,7 @@
 #include "GDCore/IDE/Project/ResourcesRenamer.h"
 #include "GDCore/Project/Behavior.h"
 #include "GDCore/Project/CustomBehavior.h"
+#include "GDCore/Project/CustomObjectConfiguration.h"
 #include "GDCore/Project/EventsFunctionsExtension.h"
 #include "GDCore/Project/Layout.h"
 #include "GDCore/Project/Object.h"
@@ -75,6 +76,16 @@ void ObjectAssetSerializer::SerializeTo(
 
   cleanObject->SerializeTo(objectAssetElement.AddChild("object"));
 
+  if (project.HasEventsBasedObject(object.GetType())) {
+    SerializerElement &variantsElement =
+        objectAssetElement.AddChild("variants");
+    variantsElement.ConsiderAsArrayOf("variant");
+
+    std::unordered_set<gd::String> alreadyUsedVariantIdentifiers;
+    gd::ObjectAssetSerializer::SerializeUsedVariantsTo(
+        project, object, variantsElement, alreadyUsedVariantIdentifiers);
+  }
+
   SerializerElement &resourcesElement =
       objectAssetElement.AddChild("resources");
   resourcesElement.ConsiderAsArrayOf("resource");
@@ -108,4 +119,46 @@ void ObjectAssetSerializer::SerializeTo(
       objectAssetElement.AddChild("customization");
   customizationElement.ConsiderAsArrayOf("empty");
 }
+
+void ObjectAssetSerializer::SerializeUsedVariantsTo(
+    gd::Project &project, const gd::Object &object,
+    SerializerElement &variantsElement,
+    std::unordered_set<gd::String> &alreadyUsedVariantIdentifiers) {
+
+  if (!project.HasEventsBasedObject(object.GetType())) {
+    return;
+  }
+  const auto *customObjectConfiguration =
+      dynamic_cast<const gd::CustomObjectConfiguration *>(
+          &object.GetConfiguration());
+  if (customObjectConfiguration
+          ->IsMarkedAsOverridingEventsBasedObjectChildrenConfiguration() ||
+      customObjectConfiguration
+          ->IsForcedToOverrideEventsBasedObjectChildrenConfiguration()) {
+    return;
+  }
+  const auto &variantName = customObjectConfiguration->GetVariantName();
+  const auto &variantIdentifier =
+      object.GetType() + gd::PlatformExtension::GetNamespaceSeparator() +
+      variantName;
+  auto insertResult = alreadyUsedVariantIdentifiers.insert(variantIdentifier);
+  if (insertResult.second) {
+    const auto &eventsBasedObject =
+        project.GetEventsBasedObject(object.GetType());
+    const auto &variants = eventsBasedObject.GetVariants();
+    const auto &variant = variants.HasVariantNamed(variantName)
+                              ? variants.GetVariant(variantName)
+                              : eventsBasedObject.GetDefaultVariant();
+
+    SerializerElement &pairElement = variantsElement.AddChild("variant");
+    pairElement.SetAttribute("objectType", object.GetType());
+    SerializerElement &variantElement = pairElement.AddChild("variant");
+    variant.SerializeTo(variantElement);
+    // TODO Recursivity
+    for (auto &object : variant.GetObjects().GetObjects()) {
+      gd::ObjectAssetSerializer::SerializeUsedVariantsTo(
+          project, *object, variantsElement, alreadyUsedVariantIdentifiers);
+    }
+  }
+}
 } // namespace gd

Core/GDCore/IDE/ObjectAssetSerializer.h

@@ -6,6 +6,7 @@
 #pragma once
 #include <map>
 #include <vector>
+#include <unordered_set>
 
 #include "GDCore/String.h"
 
@@ -52,6 +53,11 @@ class GD_CORE_API ObjectAssetSerializer {
   ObjectAssetSerializer(){};
 
   static gd::String GetObjectExtensionName(const gd::Object &object);
+
+  static void SerializeUsedVariantsTo(
+      gd::Project &project, const gd::Object &object,
+      SerializerElement &variantsElement,
+      std::unordered_set<gd::String> &alreadyUsedVariantIdentifiers);
 };
 
 } // namespace gd

Core/GDCore/IDE/ObjectVariableHelper.cpp

@@ -6,6 +6,7 @@
 #include "ObjectVariableHelper.h"
 
 #include "GDCore/IDE/WholeProjectRefactorer.h"
+#include "GDCore/Project/EventsBasedObject.h"
 #include "GDCore/Project/InitialInstancesContainer.h"
 #include "GDCore/Project/Object.h"
 #include "GDCore/Project/ObjectGroup.h"
@@ -173,6 +174,7 @@ void ObjectVariableHelper::ApplyChangesToObjects(
                                 groupVariablesContainer.Get(variableName),
                                 variablesContainer.Count());
     }
+    // TODO Check what happens if 2 variables exchange their names.
     for (const auto &pair : changeset.oldToNewVariableNames) {
       const gd::String &oldVariableName = pair.first;
       const gd::String &newVariableName = pair.second;
@@ -215,6 +217,7 @@ void ObjectVariableHelper::ApplyChangesToObjectInstances(
               destinationVariablesContainer.Remove(variableName);
             }
           }
+          // TODO Check what happens if 2 variables exchange their names.
           for (const auto &pair : changeset.oldToNewVariableNames) {
             const gd::String &oldVariableName = pair.first;
             const gd::String &newVariableName = pair.second;
@@ -236,6 +239,66 @@ void ObjectVariableHelper::ApplyChangesToObjectInstances(
             }
           }
         }
+        return false;
       });
 }
+
+void ObjectVariableHelper::ApplyChangesToVariants(
+    gd::EventsBasedObject &eventsBasedObject, const gd::String &objectName,
+    const gd::VariablesChangeset &changeset) {
+  auto &defaultVariablesContainer = eventsBasedObject.GetDefaultVariant()
+                                        .GetObjects()
+                                        .GetObject(objectName)
+                                        .GetVariables();
+  for (auto &variant : eventsBasedObject.GetVariants().GetInternalVector()) {
+    if (!variant->GetObjects().HasObjectNamed(objectName)) {
+      continue;
+    }
+    auto &object = variant->GetObjects().GetObject(objectName);
+    auto &variablesContainer = object.GetVariables();
+
+    for (const gd::String &variableName : changeset.removedVariableNames) {
+      variablesContainer.Remove(variableName);
+    }
+    for (const gd::String &variableName : changeset.addedVariableNames) {
+      if (variablesContainer.Has(variableName)) {
+        // It can happens if a child-object already had the variable but it was
+        // missing in other variant child-object.
+        continue;
+      }
+      variablesContainer.Insert(variableName,
+                                defaultVariablesContainer.Get(variableName),
+                                variablesContainer.Count());
+    }
+    // TODO Check what happens if 2 variables exchange their names.
+    for (const auto &pair : changeset.oldToNewVariableNames) {
+      const gd::String &oldVariableName = pair.first;
+      const gd::String &newVariableName = pair.second;
+      if (variablesContainer.Has(newVariableName)) {
+        // It can happens if a child-object already had the variable but it was
+        // missing in other variant child-object.
+        variablesContainer.Remove(oldVariableName);
+      } else {
+        variablesContainer.Rename(oldVariableName, newVariableName);
+      }
+    }
+    // Apply type changes
+    for (const gd::String &variableName : changeset.valueChangedVariableNames) {
+      size_t index = variablesContainer.GetPosition(variableName);
+
+      if (variablesContainer.Has(variableName) &&
+          variablesContainer.Get(variableName).GetType() !=
+              defaultVariablesContainer.Get(variableName).GetType()) {
+        variablesContainer.Remove(variableName);
+        variablesContainer.Insert(
+            variableName, defaultVariablesContainer.Get(variableName), index);
+      }
+    }
+
+    gd::ObjectVariableHelper::ApplyChangesToObjectInstances(
+        variablesContainer, variant->GetInitialInstances(), objectName,
+        changeset);
+  }
+}
+
 } // namespace gd