Snapshot Save Single Action

Extensions/3D/A_RuntimeObject3D.ts

@@ -127,8 +127,11 @@ namespace gdjs {
       };
     }
 
-    updateFromNetworkSyncData(networkSyncData: Object3DNetworkSyncData) {
-      super.updateFromNetworkSyncData(networkSyncData);
+    updateFromNetworkSyncData(
+      networkSyncData: Object3DNetworkSyncData,
+      options?: { skipMultiplayerInstructions: boolean }
+    ) {
+      super.updateFromNetworkSyncData(networkSyncData, options);
       if (networkSyncData.z !== undefined) this.setZ(networkSyncData.z);
       if (networkSyncData.w !== undefined) this.setWidth(networkSyncData.w);
       if (networkSyncData.h !== undefined) this.setHeight(networkSyncData.h);

Extensions/3D/Cube3DRuntimeObject.ts

@@ -448,9 +448,10 @@ namespace gdjs {
     }
 
     updateFromNetworkSyncData(
-      networkSyncData: Cube3DObjectNetworkSyncData
+      networkSyncData: Cube3DObjectNetworkSyncData,
+      options?: { skipMultiplayerInstructions: boolean }
     ): void {
-      super.updateFromNetworkSyncData(networkSyncData);
+      super.updateFromNetworkSyncData(networkSyncData, options);
 
       if (networkSyncData.mt !== undefined) {
         this._materialType = networkSyncData.mt;

Extensions/3D/Model3DRuntimeObject.ts

@@ -95,7 +95,6 @@ namespace gdjs {
      * @see gdjs.Model3DRuntimeObject3DRenderer.getCenterPoint
      */
     _centerPoint: FloatPoint3D | null;
-
     _animations: Model3DAnimation[];
     _currentAnimationIndex: integer = 0;
     _animationSpeedScale: float = 1;
@@ -213,9 +212,10 @@ namespace gdjs {
     }
 
     updateFromNetworkSyncData(
-      networkSyncData: Model3DObjectNetworkSyncData
+      networkSyncData: Model3DObjectNetworkSyncData,
+      options?: { skipMultiplayerInstructions: boolean }
     ): void {
-      super.updateFromNetworkSyncData(networkSyncData);
+      super.updateFromNetworkSyncData(networkSyncData, options);
 
       if (networkSyncData.mt !== undefined) {
         this._materialType = networkSyncData.mt;
@@ -251,6 +251,10 @@ namespace gdjs {
       this.onModelChanged(objectData);
     }
 
+    a(currentScene: RuntimeScene): void {
+      console.log('pomme');
+    }
+
     _updateModel(objectData: Model3DObjectData) {
       const rotationX = objectData.content.rotationX || 0;
       const rotationY = objectData.content.rotationY || 0;

Extensions/BBText/bbtextruntimeobject.ts

@@ -148,9 +148,10 @@ namespace gdjs {
     }
 
     updateFromNetworkSyncData(
-      networkSyncData: BBTextObjectNetworkSyncData
+      networkSyncData: BBTextObjectNetworkSyncData,
+      options?: { skipMultiplayerInstructions: boolean }
     ): void {
-      super.updateFromNetworkSyncData(networkSyncData);
+      super.updateFromNetworkSyncData(networkSyncData, options);
       if (this._text !== undefined) {
         this.setBBText(networkSyncData.text);
       }

Extensions/BitmapText/bitmaptextruntimeobject.ts

@@ -164,9 +164,10 @@ namespace gdjs {
     }
 
     updateFromNetworkSyncData(
-      networkSyncData: BitmapTextObjectNetworkSyncData
+      networkSyncData: BitmapTextObjectNetworkSyncData,
+      options?: { skipMultiplayerInstructions: boolean }
     ): void {
-      super.updateFromNetworkSyncData(networkSyncData);
+      super.updateFromNetworkSyncData(networkSyncData, options);
       if (this._text !== undefined) {
         this.setText(networkSyncData.text);
       }

Extensions/Lighting/lightruntimeobject.ts

@@ -95,8 +95,11 @@ namespace gdjs {
       };
     }
 
-    updateFromNetworkSyncData(networkSyncData: LightNetworkSyncData): void {
-      super.updateFromNetworkSyncData(networkSyncData);
+    updateFromNetworkSyncData(
+      networkSyncData: LightNetworkSyncData,
+      options?: { skipMultiplayerInstructions: boolean }
+    ): void {
+      super.updateFromNetworkSyncData(networkSyncData, options);
 
       if (networkSyncData.rad !== undefined) {
         this.setRadius(networkSyncData.rad);

Extensions/PanelSpriteObject/panelspriteruntimeobject.ts

@@ -132,9 +132,10 @@ namespace gdjs {
     }
 
     updateFromNetworkSyncData(
-      networkSyncData: PanelSpriteNetworkSyncData
+      networkSyncData: PanelSpriteNetworkSyncData,
+      options?: { skipMultiplayerInstructions: boolean }
     ): void {
-      super.updateFromNetworkSyncData(networkSyncData);
+      super.updateFromNetworkSyncData(networkSyncData, options);
 
       // Texture is not synchronized, see if this is asked or not.
 

Extensions/ParticleSystem/particleemitterobject.ts

@@ -399,9 +399,10 @@ namespace gdjs {
     }
 
     updateFromNetworkSyncData(
-      syncData: ParticleEmitterObjectNetworkSyncData
+      syncData: ParticleEmitterObjectNetworkSyncData,
+      options?: { skipMultiplayerInstructions: boolean }
     ): void {
-      super.updateFromNetworkSyncData(syncData);
+      super.updateFromNetworkSyncData(syncData, options);
       if (syncData.x !== undefined) {
         this.setX(syncData.x);
       }

Extensions/SaveState/JsExtension.js

@@ -0,0 +1,68 @@
+//@ts-check
+/// <reference path="../JsExtensionTypes.d.ts" />
+/**
+ * This is a declaration of an extension for GDevelop 5.
+ *
+ * ℹ️ Changes in this file are watched and automatically imported if the editor
+ * is running. You can also manually run `node import-GDJS-Runtime.js` (in newIDE/app/scripts).
+ *
+ * The file must be named "JsExtension.js", otherwise GDevelop won't load it.
+ * ⚠️ If you make a change and the extension is not loaded, open the developer console
+ * and search for any errors.
+ *
+ * More information on https://github.com/4ian/GDevelop/blob/master/newIDE/README-extensions.md
+ */
+
+/** @type {ExtensionModule} */
+module.exports = {
+  createExtension: function (_, gd) {
+    const extension = new gd.PlatformExtension();
+    extension
+      .setExtensionInformation(
+        'SaveState',
+        _('Save State'),
+
+        'This allows to save and load whole games.',
+        'Neyl Mahfouf',
+        'Gdevelop'
+      )
+      .setExtensionHelpPath('/all-features/device-vibration')
+      .setCategory('User interface');
+    extension
+      .addInstructionOrExpressionGroupMetadata(_('Save State'))
+      .setIcon('JsPlatform/Extensions/vibration_start32.png');
+
+    extension
+      .addAction(
+        'SyncAll',
+        _('Save the whole game'),
+        _('Save the wole game.'),
+        _('Syncall'),
+        'res/conditions/animation24.png',
+        'res/conditions/animation.png'
+      )
+      .addCodeOnlyParameter('currentScene', '')
+      .getCodeExtraInformation()
+      .setIncludeFile('Extensions/SaveState/savestatetools.js')
+      .setFunctionName('gdjs.saveState.saveWholeGame');
+
+    extension
+      .addAction(
+        'LoadAll',
+        _('Load the whole game'),
+        _('Load the wole game.'),
+        _('Loadall'),
+        'res/conditions/animation24.png',
+        'res/conditions/animation.png'
+      )
+      .addCodeOnlyParameter('currentScene', '')
+      .getCodeExtraInformation()
+      .setIncludeFile('Extensions/SaveState/savestatetools.js')
+      .setFunctionName('gdjs.saveState.loadWholeGame');
+
+    return extension;
+  },
+  runExtensionSanityTests: function (gd, extension) {
+    return [];
+  },
+};

Extensions/SaveState/savestatetools.ts

@@ -0,0 +1,56 @@
+namespace gdjs {
+  export namespace saveState {
+    const fs = require('fs');
+    export const saveWholeGame = function (currentScene: RuntimeScene) {
+      let allSyncData: GameSaveState = {
+        gameNetworkSyncData: {},
+        layoutNetworkSyncDatas: [],
+      };
+      const gameData = currentScene
+        .getGame()
+        .getNetworkSyncData({ syncEverythingForWholeGameSaveState: true });
+      const sceneStack = currentScene.getGame()._sceneStack._stack;
+      if (gameData) {
+        allSyncData.gameNetworkSyncData = gameData;
+      }
+
+      if (sceneStack) {
+        sceneStack.forEach((scene, index) => {
+          const sceneDatas = scene.getNetworkSyncData({
+            syncEverythingForWholeGameSaveState: true,
+          });
+          scene._variablesByExtensionName;
+
+          if (sceneDatas) {
+            allSyncData.layoutNetworkSyncDatas[index] = {
+              sceneData: {} as LayoutNetworkSyncData,
+              objectDatas: {},
+            };
+            allSyncData.layoutNetworkSyncDatas[index].sceneData = sceneDatas;
+            const sceneObjects = scene.getAdhocListOfAllInstances();
+            for (const key in sceneObjects) {
+              if (sceneObjects.hasOwnProperty(key)) {
+                const object = sceneObjects[key];
+                const syncData = object.getNetworkSyncData(true);
+                allSyncData.layoutNetworkSyncDatas[index].objectDatas[
+                  object.name
+                ] = syncData;
+              }
+            }
+          }
+        });
+      }
+      const syncDataJson = JSON.stringify(allSyncData);
+      localStorage.setItem('save', syncDataJson);
+      fs.writeFile('UsersData.json', syncDataJson, (error) => {
+        if (error) {
+          console.error(error);
+        }
+      });
+    };
+
+    export const loadWholeGame = function (currentScene: RuntimeScene) {
+      currentScene.requestLoad();
+    };
+  }
+}

Extensions/Spine/spineruntimeobject.ts

@@ -131,8 +131,11 @@ namespace gdjs {
       };
     }
 
-    updateFromNetworkSyncData(syncData: SpineNetworkSyncData): void {
-      super.updateFromNetworkSyncData(syncData);
+    updateFromNetworkSyncData(
+      syncData: SpineNetworkSyncData,
+      options?: { skipMultiplayerInstructions: boolean }
+    ): void {
+      super.updateFromNetworkSyncData(syncData, options);
 
       if (syncData.opa !== undefined && syncData.opa !== this._opacity) {
         this.setOpacity(syncData.opa);

Extensions/TextInput/textinputruntimeobject.ts

@@ -278,8 +278,11 @@ namespace gdjs {
       };
     }
 
-    updateFromNetworkSyncData(syncData: TextInputNetworkSyncData): void {
-      super.updateFromNetworkSyncData(syncData);
+    updateFromNetworkSyncData(
+      syncData: TextInputNetworkSyncData,
+      options?: { skipMultiplayerInstructions: boolean }
+    ): void {
+      super.updateFromNetworkSyncData(syncData, options);
 
       if (syncData.opa !== undefined) this.setOpacity(syncData.opa);
       if (syncData.wid !== undefined) this.setWidth(syncData.wid);

Extensions/TextObject/textruntimeobject.ts

@@ -243,9 +243,10 @@ namespace gdjs {
     }
 
     updateFromNetworkSyncData(
-      networkSyncData: TextObjectNetworkSyncData
+      networkSyncData: TextObjectNetworkSyncData,
+      options?: { skipMultiplayerInstructions: boolean }
     ): void {
-      super.updateFromNetworkSyncData(networkSyncData);
+      super.updateFromNetworkSyncData(networkSyncData, options);
       if (networkSyncData.str !== undefined) {
         this.setText(networkSyncData.str);
       }

Extensions/TileMap/simpletilemapruntimeobject.ts

@@ -176,9 +176,10 @@ namespace gdjs {
     }
 
     updateFromNetworkSyncData(
-      networkSyncData: SimpleTileMapNetworkSyncData
+      networkSyncData: SimpleTileMapNetworkSyncData,
+      options?: { skipMultiplayerInstructions: boolean }
     ): void {
-      super.updateFromNetworkSyncData(networkSyncData);
+      super.updateFromNetworkSyncData(networkSyncData, options);
 
       if (
         networkSyncData.op !== undefined &&

Extensions/TileMap/tilemapcollisionmaskruntimeobject.ts

@@ -208,9 +208,10 @@ namespace gdjs {
     }
 
     updateFromNetworkSyncData(
-      networkSyncData: TilemapCollisionMaskNetworkSyncData
+      networkSyncData: TilemapCollisionMaskNetworkSyncData,
+      options?: { skipMultiplayerInstructions: boolean }
     ): void {
-      super.updateFromNetworkSyncData(networkSyncData);
+      super.updateFromNetworkSyncData(networkSyncData, options);
 
       if (networkSyncData.tmjf !== undefined) {
         this.setTilemapJsonFile(networkSyncData.tmjf);

Extensions/TileMap/tilemapruntimeobject.ts

@@ -163,8 +163,11 @@ namespace gdjs {
       };
     }
 
-    updateFromNetworkSyncData(networkSyncData: TilemapNetworkSyncData): void {
-      super.updateFromNetworkSyncData(networkSyncData);
+    updateFromNetworkSyncData(
+      networkSyncData: TilemapNetworkSyncData,
+      options?: { skipMultiplayerInstructions: boolean }
+    ): void {
+      super.updateFromNetworkSyncData(networkSyncData, options);
 
       if (networkSyncData.op !== undefined) {
         this.setOpacity(networkSyncData.op);

Extensions/TiledSpriteObject/tiledspriteruntimeobject.ts

@@ -93,9 +93,10 @@ namespace gdjs {
     }
 
     updateFromNetworkSyncData(
-      networkSyncData: TiledSpriteNetworkSyncData
+      networkSyncData: TiledSpriteNetworkSyncData,
+      options?: { skipMultiplayerInstructions: boolean }
     ): void {
-      super.updateFromNetworkSyncData(networkSyncData);
+      super.updateFromNetworkSyncData(networkSyncData, options);
 
       // Texture is not synchronized, see if this is asked or not.
 

Extensions/Video/videoruntimeobject.ts

@@ -114,8 +114,11 @@ namespace gdjs {
       };
     }
 
-    updateFromNetworkSyncData(syncData: VideoNetworkSyncData): void {
-      super.updateFromNetworkSyncData(syncData);
+    updateFromNetworkSyncData(
+      syncData: VideoNetworkSyncData,
+      options?: { skipMultiplayerInstructions: boolean }
+    ): void {
+      super.updateFromNetworkSyncData(syncData, options);
 
       if (this._opacity !== undefined && this._opacity && syncData.op) {
         this.setOpacity(syncData.op);

GDJS/Runtime/runtimegame.ts

@@ -1360,14 +1360,18 @@ namespace gdjs {
         const extensionVariablesSyncData =
           variables.getNetworkSyncData(syncOptions);
         // If there is no variables to sync, don't include the extension in the sync data.
-        if (extensionVariablesSyncData.length) {
+        if (
+          extensionVariablesSyncData.length &&
+          !syncOptions.syncEverythingForWholeGameSaveState
+        ) {
           extensionsVariablesSyncData[extensionName] =
             extensionVariablesSyncData;
         }
       });
       syncData.extVar = extensionsVariablesSyncData;
 
       if (
+        !syncOptions.syncEverythingForWholeGameSaveState &&
         (!syncData.var || syncData.var.length === 0) &&
         !syncData.ss &&
         (!syncData.extVar || Object.keys(syncData.extVar).length === 0)
@@ -1379,10 +1383,13 @@ namespace gdjs {
       return syncData;
     }
 
-    updateFromNetworkSyncData(syncData: GameNetworkSyncData) {
+    updateFromNetworkSyncData(
+      syncData: GameNetworkSyncData,
+      options?: { skipMultiplayerInstructions: boolean }
+    ) {
       this._throwIfDisposed();
       if (syncData.var) {
-        this._variables.updateFromNetworkSyncData(syncData.var);
+        this._variables.updateFromNetworkSyncData(syncData.var, options);
       }
       if (syncData.ss) {
         this._sceneStack.updateFromNetworkSyncData(syncData.ss);