.eslintrc.json

@@ -3,8 +3,7 @@
   "ignorePatterns": [
     "app/**/*", // ignore nodeJs files
     "dist/**/*",
-    "release/**/*",
+    "release/**/*"
-    "src/**/*"
   ],
   "overrides": [
     {

app/LoadModel.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadModel = void 0;
+class LoadModel {
+    constructor(jsonString, modelType) {
+        this.jsonString = jsonString;
+        this.modelType = modelType;
+    }
+}
+exports.LoadModel = LoadModel;
+//# sourceMappingURL=LoadModel.js.map

app/LoadModel.ts

@@ -0,0 +1,12 @@
+import {ModelComponentType} from "../src/app/game-model/ModelComponentType";
+
+export class LoadModel {
+  jsonString: string
+  modelType: ModelComponentType
+
+
+  constructor(jsonString: string, modelType: ModelComponentType) {
+    this.jsonString = jsonString;
+    this.modelType = modelType;
+  }
+}

app/LoadedProject.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LoadedProject = void 0;
+class LoadedProject {
+    constructor(projectName, loadedModels) {
+        this.projectName = projectName;
+        this.loadedModels = loadedModels;
+    }
+}
+exports.LoadedProject = LoadedProject;
+//# sourceMappingURL=LoadedProject.js.map

app/LoadedProject.ts

@@ -0,0 +1,12 @@
+import {LoadModel} from "./LoadModel";
+
+export class LoadedProject {
+  projectName: string
+  loadedModels: LoadModel[]
+
+
+  constructor(projectName: string, loadedModels: LoadModel[]) {
+    this.projectName = projectName;
+    this.loadedModels = loadedModels;
+  }
+}

app/RecursiveLoadModel.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RecursiveLoadModel = void 0;
+const LoadModel_1 = require("./LoadModel");
+class RecursiveLoadModel extends LoadModel_1.LoadModel {
+    constructor(jsonString, modelType, parentLoadModelname) {
+        super(jsonString, modelType);
+        this.parentLoadModelname = parentLoadModelname;
+    }
+}
+exports.RecursiveLoadModel = RecursiveLoadModel;
+//# sourceMappingURL=RecursiveLoadModel.js.map

app/RecursiveLoadModel.ts

@@ -0,0 +1,12 @@
+import {LoadModel} from "./LoadModel";
+import {ModelComponentType} from "../src/app/game-model/ModelComponentType";
+
+export class RecursiveLoadModel extends LoadModel {
+  parentLoadModelname: string
+
+
+  constructor(jsonString: string, modelType: ModelComponentType, parentLoadModelname: string) {
+    super(jsonString, modelType);
+    this.parentLoadModelname = parentLoadModelname;
+  }
+}

app/SaveProject.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SaveProject = void 0;
+const fs = require("fs");
+const path = require("node:path");
+const LoadModel_1 = require("./LoadModel");
+const ModelComponentType_1 = require("../src/app/game-model/ModelComponentType");
+const LoadedProject_1 = require("./LoadedProject");
+const RecursiveLoadModel_1 = require("./RecursiveLoadModel");
+class SaveProject {
+    static saveProject(projectDir, storageModels) {
+        if (!fs.existsSync(projectDir)) {
+            fs.mkdirSync(projectDir, { recursive: true });
+        }
+        console.log(storageModels);
+        storageModels.forEach(storageModel => {
+            let modelDir = path.join(projectDir, storageModel.storageRootDir);
+            storageModel.storagePath.forEach(pathElement => modelDir = path.join(modelDir, pathElement));
+            if (!fs.existsSync(modelDir)) {
+                fs.mkdirSync(modelDir, { recursive: true });
+            }
+            const filePath = path.join(modelDir, storageModel.fileName + ".json");
+            fs.writeFile(filePath, storageModel.jsonString, 'utf-8', (err) => {
+                if (err) {
+                    console.error('Error writing JSON to file:', err);
+                }
+                else {
+                    console.log('JSON file saved successfully:', filePath);
+                }
+            });
+        });
+    }
+    static loadProject(projectDir) {
+        let loadedScriptAccounts = SaveProject.loadScriptAccounts(projectDir);
+        loadedScriptAccounts = loadedScriptAccounts.concat(SaveProject.loadGamesystems(projectDir));
+        return new LoadedProject_1.LoadedProject(path.basename(projectDir), loadedScriptAccounts);
+    }
+    static loadScriptAccounts(projectDir) {
+        const scriptAccountDir = path.join(projectDir, "script-accounts");
+        if (!fs.existsSync(scriptAccountDir)) {
+            return [];
+        }
+        const loadedScriptAccounts = [];
+        const scriptAccountFileNames = fs.readdirSync(scriptAccountDir);
+        scriptAccountFileNames.forEach(scriptAccountFileName => {
+            const scriptAccountFile = path.join(scriptAccountDir, scriptAccountFileName);
+            const scriptAccountData = fs.readFileSync(scriptAccountFile, 'utf-8');
+            loadedScriptAccounts.push({
+                modelType: ModelComponentType_1.ModelComponentType.SCRIPTACCOUNT,
+                jsonString: scriptAccountData
+            });
+        });
+        return loadedScriptAccounts;
+    }
+    static loadGamesystems(projectDir) {
+        const gamesystemDir = path.join(projectDir, "gamesystems");
+        if (fs.existsSync(gamesystemDir)) {
+            const loadedGamesystems = this.loadGamesystemsRecursively(gamesystemDir);
+            console.log("LoadedGamesystems: ", loadedGamesystems.length);
+            return loadedGamesystems;
+        }
+        else {
+            return [];
+        }
+    }
+    static loadGamesystemsRecursively(gamesystemDir) {
+        let loadedGamesystems = [];
+        const gamesystemFileNames = fs.readdirSync(gamesystemDir);
+        gamesystemFileNames.forEach(fileName => {
+            const gamesystemPath = path.join(gamesystemDir, fileName);
+            if (fs.lstatSync(gamesystemPath).isDirectory()) {
+                const childModels = SaveProject.loadGamesystemsRecursively(gamesystemPath);
+                loadedGamesystems = loadedGamesystems.concat(childModels);
+            }
+            else {
+                const gamesystemData = fs.readFileSync(path.join(gamesystemDir, fileName), "utf-8");
+                if (path.parse(fileName).name === path.basename(gamesystemDir)) {
+                    if ((path.basename(gamesystemDir) === path.parse(fileName).name) && path.basename(path.parse(gamesystemDir).dir) === "gamesystems") {
+                        const loadedModel = new LoadModel_1.LoadModel(gamesystemData, ModelComponentType_1.ModelComponentType.GAMESYTEM);
+                        loadedGamesystems.unshift(loadedModel);
+                    }
+                    else {
+                        const loadedModel = new RecursiveLoadModel_1.RecursiveLoadModel(gamesystemData, ModelComponentType_1.ModelComponentType.GAMESYTEM, path.basename(gamesystemDir));
+                        loadedGamesystems.unshift(loadedModel);
+                    }
+                }
+                else {
+                    const secondCon = path.basename(gamesystemDir) === path.parse(fileName).name;
+                    const thirdCon = path.basename(path.parse(gamesystemDir).dir) === "gamesystems";
+                    if (path.basename(gamesystemDir) === "gamesystems") {
+                        const loadedModel = new LoadModel_1.LoadModel(gamesystemData, ModelComponentType_1.ModelComponentType.GAMESYTEM);
+                        loadedGamesystems.push(loadedModel);
+                    }
+                    else {
+                        const loadedModel = new RecursiveLoadModel_1.RecursiveLoadModel(gamesystemData, ModelComponentType_1.ModelComponentType.GAMESYTEM, path.basename(gamesystemDir));
+                        loadedGamesystems.push(loadedModel);
+                    }
+                }
+            }
+        });
+        return loadedGamesystems;
+    }
+}
+exports.SaveProject = SaveProject;
+//# sourceMappingURL=SaveProject.js.map

app/SaveProject.ts

@@ -0,0 +1,114 @@
+import {StorageModel} from "../src/app/game-model/fs/StorageModel";
+import * as fs from "fs";
+import * as path from "node:path";
+import {LoadModel} from "./LoadModel";
+import {ModelComponentType} from "../src/app/game-model/ModelComponentType";
+import {LoadedProject} from "./LoadedProject";
+import {RecursiveLoadModel} from "./RecursiveLoadModel";
+
+
+export class SaveProject {
+  static saveProject(projectDir: string, storageModels: StorageModel[]) {
+    if(!fs.existsSync(projectDir)) {
+      fs.mkdirSync(projectDir, {recursive: true});
+    }
+
+    console.log(storageModels)
+    storageModels.forEach(storageModel => {
+      let modelDir = path.join(projectDir, storageModel.storageRootDir);
+      storageModel.storagePath.forEach(pathElement => modelDir = path.join(modelDir, pathElement));
+      if(!fs.existsSync(modelDir)) {
+        fs.mkdirSync(modelDir, {recursive: true});
+      }
+
+      const filePath = path.join(modelDir, storageModel.fileName + ".json");
+      fs.writeFile(filePath, storageModel.jsonString ,'utf-8', (err) => {
+        if (err) {
+          console.error('Error writing JSON to file:', err);
+        } else {
+          console.log('JSON file saved successfully:', filePath);
+        }
+      })
+    })
+  }
+
+  static loadProject(projectDir: string) {
+    let loadedScriptAccounts: LoadModel[] = SaveProject.loadScriptAccounts(projectDir)
+    loadedScriptAccounts = loadedScriptAccounts.concat(SaveProject.loadGamesystems(projectDir))
+    return new LoadedProject(path.basename(projectDir), loadedScriptAccounts);
+  }
+
+  static loadScriptAccounts(projectDir: string): LoadModel[] {
+    const scriptAccountDir = path.join(projectDir, "script-accounts");
+    if (!fs.existsSync(scriptAccountDir)) {
+      return [];
+    }
+
+    const loadedScriptAccounts: LoadModel[] = [];
+
+    const scriptAccountFileNames = fs.readdirSync(scriptAccountDir);
+    scriptAccountFileNames.forEach(scriptAccountFileName => {
+      const scriptAccountFile = path.join(scriptAccountDir, scriptAccountFileName)
+      const scriptAccountData: string = fs.readFileSync(scriptAccountFile, 'utf-8');
+
+      loadedScriptAccounts.push({
+        modelType: ModelComponentType.SCRIPTACCOUNT,
+        jsonString: scriptAccountData
+      });
+    })
+
+    return loadedScriptAccounts;
+  }
+
+  static loadGamesystems(projectDir: string): LoadModel[] {
+    const gamesystemDir = path.join(projectDir, "gamesystems");
+    if(fs.existsSync(gamesystemDir)) {
+      const loadedGamesystems = this.loadGamesystemsRecursively(gamesystemDir);
+      console.log("LoadedGamesystems: ", loadedGamesystems.length);
+      return loadedGamesystems;
+    } else {
+      return []
+    }
+  }
+
+  static loadGamesystemsRecursively(gamesystemDir: string): LoadModel[] {
+    let loadedGamesystems: LoadModel[] = [];
+    const gamesystemFileNames = fs.readdirSync(gamesystemDir);
+
+    gamesystemFileNames.forEach(fileName => {
+      const gamesystemPath = path.join(gamesystemDir, fileName);
+
+      if(fs.lstatSync(gamesystemPath).isDirectory()) {
+        const childModels: LoadModel[] = SaveProject.loadGamesystemsRecursively(gamesystemPath);
+        loadedGamesystems = loadedGamesystems.concat(childModels);
+      } else {
+        const gamesystemData = fs.readFileSync(path.join(gamesystemDir, fileName), "utf-8");
+        if(path.parse(fileName).name === path.basename(gamesystemDir) ) {
+          if((path.basename(gamesystemDir) === path.parse(fileName).name) && path.basename(path.parse(gamesystemDir).dir) === "gamesystems") {
+            const loadedModel = new LoadModel(gamesystemData, ModelComponentType.GAMESYTEM);
+            loadedGamesystems.unshift(loadedModel)
+          } else {
+            const loadedModel = new RecursiveLoadModel(gamesystemData, ModelComponentType.GAMESYTEM, path.basename(gamesystemDir))
+            loadedGamesystems.unshift(loadedModel);
+          }
+
+        } else {
+          const secondCon = path.basename(gamesystemDir) === path.parse(fileName).name
+          const thirdCon = path.basename(path.parse(gamesystemDir).dir) === "gamesystems"
+
+          if(path.basename(gamesystemDir) === "gamesystems"){
+            const loadedModel = new LoadModel(gamesystemData, ModelComponentType.GAMESYTEM)
+            loadedGamesystems.push(loadedModel);
+          } else {
+
+            const loadedModel = new RecursiveLoadModel(gamesystemData, ModelComponentType.GAMESYTEM, path.basename(gamesystemDir))
+            loadedGamesystems.push(loadedModel);
+          }
+
+        }
+      }
+    })
+    return loadedGamesystems;
+  }
+
+}

app/StorageModel.ts

@@ -0,0 +1,12 @@
+class StorageModel {
+  jsonString: string
+  fileName: string
+  storageDir: string
+
+
+  constructor(jsonString: string, fileName: string, storageDir: string) {
+    this.jsonString = jsonString;
+    this.fileName = fileName;
+    this.storageDir = storageDir;
+  }
+}

app/main.ts

@@ -1,11 +1,9 @@
-import {app, BrowserWindow, dialog, globalShortcut, ipcMain, Menu, screen} from 'electron';
+import {app, BrowserWindow, screen, Menu, ipcMain, dialog, globalShortcut} from 'electron';
 import * as path from 'path';
 import * as fs from 'fs';
-import {GameModelLoader} from "./storage/loader/GameModelLoader";
+import {json} from "node:stream/consumers";
-import {StoredGameModel} from "./storage/StoredGameModel";
+import {StorageModel} from "../src/app/game-model/fs/StorageModel";
-import {ScriptAccountStorage} from "./storage/storing/ScriptAccountStoring";
+import {SaveProject} from "./SaveProject";
-import {ModelComponentFileDirectory} from "./storage/ModelComponentFileDirectory";
-import {GamesystemStorage} from "./storage/storing/GamesystemStorage";
 
 let win: BrowserWindow | null = null;
 const args = process.argv.slice(1),
@@ -96,15 +94,11 @@ function createWindow(): BrowserWindow {
     contextMenu.popup({ window: win!, x: params.x, y: params.y });
   })
 
-  ipcMain.on('save-model', (event, storedGameModel: StoredGameModel) => {
+  ipcMain.on('save-model', (event, storageModels: StorageModel[]) => {
-    recieveGameModelToStore(storedGameModel)
+    console.log("Save Model")
+    SaveProject.saveProject(projectDirectory, storageModels);
   })
 
-  /*ipcMain.on('delete-component', (event, deletedComponent: DeleteModel) => {
-    console.log("Delete Model: ", deletedComponent)
-      deleteComponent(deletedComponent);
-  })*/
-
   const menuTemplate = [
     {
       label: 'File',
@@ -132,6 +126,7 @@ function createWindow(): BrowserWindow {
   ]
   const menu = Menu.buildFromTemplate(menuTemplate);
   Menu.setApplicationMenu(menu)
+  loadDevProjectAtStart()
 
   win.webContents.on('did-finish-load', () => {
     loadDevProjectAtStart()
@@ -204,28 +199,11 @@ function loadDevProjectAtStart() {
 
 function openProjectFromFile(openProjectDir: string) {
   projectDirectory = openProjectDir
-  const gameModelLoader = new GameModelLoader(openProjectDir);
+  console.log("Open Project-Directory: ", openProjectDir)
-  const loadedProject = gameModelLoader.loadGameModel();
+  const loadedProject = SaveProject.loadProject(openProjectDir)
   win!.webContents.send("open-project", loadedProject)
 }
 
 function saveProject() {
   win!.webContents.send('get-project-data')
 }
-
-function recieveGameModelToStore(gameModel: StoredGameModel) {
-  const scriptAccountStorage = new ScriptAccountStorage(path.join(projectDirectory, ModelComponentFileDirectory.SCRIPTACCOUNT_DIR_NAME))
-  scriptAccountStorage.storeScriptAccounts(gameModel.storedScriptAccounts)
-
-  const gamesystemStorage = new GamesystemStorage(path.join(projectDirectory, ModelComponentFileDirectory.GAMESYSTEM_DIR_NAME))
-  gamesystemStorage.storeGamesystems(gameModel.storedGamesystems)
-}
-
-/*function deleteComponent(component: DeleteModel) {
-  console.log("Delete Component")
-  if(component.modeltype == ModelComponentType.SCRIPTACCOUNT) {
-    DeleteTransaction.deleteScriptAccount(projectDirectory, component.componentName);
-  } else if(component.modeltype === ModelComponentType.GAMESYTEM) {
-    DeleteTransaction.deleteGamesystem(projectDirectory, component.componentName);
-  }
-}*/

app/storage/FileUtils.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FileUtils = void 0;
-const fs = require("fs");
-const path = require("node:path");
-const fs_1 = require("fs");
-class FileUtils {
-    static listFilesInDirectory(directory) {
-        if (fs.lstatSync(directory).isDirectory()) {
-            return fs.readdirSync(directory).map(fileName => path.join(directory, fileName));
-        }
-        else {
-            return [];
-        }
-    }
-    static prepareFileForWriting(file) {
-        const parentDirectory = path.dirname(file);
-        if (!fs.existsSync(parentDirectory)) {
-            (0, fs_1.mkdirSync)(parentDirectory, { recursive: true });
-        }
-    }
-    static removeFiles(files) {
-        files.forEach(file => {
-            if (fs.lstatSync(file).isDirectory()) {
-                fs.rmdirSync(file);
-            }
-            else {
-                fs.unlinkSync(file);
-            }
-        });
-    }
-}
-exports.FileUtils = FileUtils;
-//# sourceMappingURL=FileUtils.js.map

app/storage/FileUtils.ts

@@ -1,33 +0,0 @@
-import * as fs from "fs";
-import * as path from "node:path";
-import {mkdirSync} from "fs";
-import {lstatSync} from "node:fs";
-
-
-export class FileUtils {
-  public static listFilesInDirectory(directory: string) {
-    if(fs.lstatSync(directory).isDirectory()) {
-      return fs.readdirSync(directory).map(fileName => path.join(directory, fileName))
-    } else {
-      return [];
-    }
-  }
-
-  public static prepareFileForWriting(file: string) {
-    const parentDirectory = path.dirname(file)
-
-    if(!fs.existsSync(parentDirectory)) {
-      mkdirSync(parentDirectory, {recursive: true})
-    }
-  }
-
-  public static removeFiles(files: string[]) {
-    files.forEach(file => {
-      if(fs.lstatSync(file).isDirectory()) {
-        fs.rmdirSync(file)
-      } else {
-        fs.unlinkSync(file);
-      }
-    })
-  }
-}

app/storage/ModelComponentFileDirectory.js

@@ -1,11 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ModelComponentFileDirectory = void 0;
-class ModelComponentFileDirectory {
-}
-exports.ModelComponentFileDirectory = ModelComponentFileDirectory;
-ModelComponentFileDirectory.SCRIPTACCOUNT_DIR_NAME = "script-accounts";
-ModelComponentFileDirectory.GAMESYSTEM_DIR_NAME = "gamesystems";
-ModelComponentFileDirectory.GAMESYSTEM_SIMPLE_DIR_NAME = "simple";
-ModelComponentFileDirectory.GAMESYSTEM_PRODUCT_DIR_NAME = "product";
-//# sourceMappingURL=ModelComponentFileDirectory.js.map

app/storage/ModelComponentFileDirectory.ts

@@ -1,6 +0,0 @@
-export class ModelComponentFileDirectory {
-  public static SCRIPTACCOUNT_DIR_NAME = "script-accounts"
-  public static GAMESYSTEM_DIR_NAME = "gamesystems";
-  public static GAMESYSTEM_SIMPLE_DIR_NAME = "simple";
-  public static GAMESYSTEM_PRODUCT_DIR_NAME = "product";
-}

app/storage/StoreComponent.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StoreComponent = void 0;
-class StoreComponent {
-    constructor(jsonString, fileName, componentType) {
-        this.jsonString = jsonString;
-        this.fileName = fileName;
-        this.componentType = componentType;
-    }
-}
-exports.StoreComponent = StoreComponent;
-//# sourceMappingURL=StoreComponent.js.map

app/storage/StoreComponent.ts

@@ -1,13 +0,0 @@
-import {ModelComponentType} from "../../src/app/project/game-model/ModelComponentType";
-
-
-export class StoreComponent {
-  jsonString: string
-  fileName: string
-  componentType: ModelComponentType
-  constructor(jsonString: string, fileName: string, componentType: ModelComponentType) {
-    this.jsonString = jsonString;
-    this.fileName = fileName;
-    this.componentType = componentType
-  }
-}

app/storage/StoredGameModel.js

@@ -1,12 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.StoredGameModel = void 0;
-class StoredGameModel {
-    constructor(gameModelName, storedScriptAccounts, storedGamesystems) {
-        this.gameModelName = gameModelName;
-        this.storedGamesystems = storedGamesystems;
-        this.storedScriptAccounts = storedScriptAccounts;
-    }
-}
-exports.StoredGameModel = StoredGameModel;
-//# sourceMappingURL=StoredGameModel.js.map

app/storage/StoredGameModel.ts

@@ -1,15 +0,0 @@
-import {StoreComponent} from "./StoreComponent";
-
-export class StoredGameModel {
-  gameModelName: string
-
-  storedGamesystems: StoreComponent[]
-  storedScriptAccounts: StoreComponent[]
-
-
-  constructor(gameModelName: string, storedScriptAccounts: StoreComponent[], storedGamesystems: StoreComponent[]) {
-    this.gameModelName = gameModelName;
-    this.storedGamesystems = storedGamesystems;
-    this.storedScriptAccounts = storedScriptAccounts;
-  }
-}

app/storage/loader/GameModelLoader.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GameModelLoader = void 0;
-const StoredGameModel_1 = require("../StoredGameModel");
-const path = require("node:path");
-const ModelComponentFileDirectory_1 = require("../ModelComponentFileDirectory");
-const ScriptAccountLoader_1 = require("./ScriptAccountLoader");
-const GamesystemLoader_1 = require("./GamesystemLoader");
-class GameModelLoader {
-    constructor(gameModelDir) {
-        this.gameModelDir = gameModelDir;
-    }
-    loadGameModel() {
-        const gameModelName = path.basename(this.gameModelDir);
-        const storedScriptAccounts = this.loadScriptAccountComponents();
-        const storedGamesystems = this.loadGamesystems();
-        return new StoredGameModel_1.StoredGameModel(gameModelName, storedScriptAccounts, storedGamesystems);
-    }
-    loadScriptAccountComponents() {
-        const scriptAccountDir = path.join(this.gameModelDir, ModelComponentFileDirectory_1.ModelComponentFileDirectory.SCRIPTACCOUNT_DIR_NAME);
-        const scriptAccountLoader = new ScriptAccountLoader_1.ScriptAccountLoader(scriptAccountDir);
-        return scriptAccountLoader.loadScriptAccounts();
-    }
-    loadGamesystems() {
-        const gamesystemDir = path.join(this.gameModelDir, ModelComponentFileDirectory_1.ModelComponentFileDirectory.GAMESYSTEM_DIR_NAME);
-        const gamesystemLoader = new GamesystemLoader_1.GamesystemLoader(gamesystemDir);
-        return gamesystemLoader.loadGamesystems();
-    }
-}
-exports.GameModelLoader = GameModelLoader;
-//# sourceMappingURL=GameModelLoader.js.map

app/storage/loader/GameModelLoader.ts

@@ -1,42 +0,0 @@
-import {StoredGameModel} from "../StoredGameModel";
-import {StoreComponent} from "../StoreComponent";
-import * as path from "node:path";
-import * as fs from "fs";
-import {ModelComponentFileDirectory} from "../ModelComponentFileDirectory";
-import {ScriptAccountLoader} from "./ScriptAccountLoader";
-import {GamesystemLoader} from "./GamesystemLoader";
-
-export class GameModelLoader {
-  gameModelDir: string
-
-
-  constructor(gameModelDir: string) {
-    this.gameModelDir = gameModelDir;
-  }
-
-  loadGameModel(): StoredGameModel {
-    const gameModelName = path.basename(this.gameModelDir)
-
-    const storedScriptAccounts = this.loadScriptAccountComponents();
-    const storedGamesystems = this.loadGamesystems();
-
-    return new StoredGameModel(gameModelName, storedScriptAccounts, storedGamesystems);
-  }
-
-  private loadScriptAccountComponents() {
-    const scriptAccountDir = path.join(this.gameModelDir, ModelComponentFileDirectory.SCRIPTACCOUNT_DIR_NAME);
-    const scriptAccountLoader = new ScriptAccountLoader(scriptAccountDir);
-    return scriptAccountLoader.loadScriptAccounts()
-  }
-
-  private loadGamesystems(): StoreComponent[] {
-    const gamesystemDir = path.join(this.gameModelDir, ModelComponentFileDirectory.GAMESYSTEM_DIR_NAME);
-    const gamesystemLoader = new GamesystemLoader(gamesystemDir);
-    return gamesystemLoader.loadGamesystems();
-  }
-
-
-
-
-
-}

app/storage/loader/GamesystemLoader.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GamesystemLoader = void 0;
-const StoreComponent_1 = require("../StoreComponent");
-const FileUtils_1 = require("../FileUtils");
-const fs = require("fs");
-const path = require("node:path");
-const ModelComponentType_1 = require("../../../src/app/project/game-model/ModelComponentType");
-class GamesystemLoader {
-    constructor(gamesystemDir) {
-        this.gamesystemDir = gamesystemDir;
-    }
-    loadGamesystems() {
-        return this.loadGamesystemsRecursivly(this.gamesystemDir);
-    }
-    loadGamesystemsRecursivly(currentGamesystemDir) {
-        let loadedGamesystems = [];
-        const gamesystemFiles = FileUtils_1.FileUtils.listFilesInDirectory(currentGamesystemDir);
-        gamesystemFiles.forEach(gamesystemFile => {
-            if (fs.lstatSync(gamesystemFile).isDirectory()) {
-                const childGamesystems = this.loadGamesystemsRecursivly(gamesystemFile);
-                loadedGamesystems = loadedGamesystems.concat(childGamesystems);
-            }
-            else if (path.basename(gamesystemFile).endsWith(".json")) {
-                const loadedGamesystem = this.loadGamesystem(gamesystemFile);
-                if (loadedGamesystem != undefined) {
-                    loadedGamesystems.push(loadedGamesystem);
-                }
-            }
-        });
-        return loadedGamesystems;
-    }
-    loadGamesystem(gamesystemFile) {
-        if (gamesystemFile.endsWith(".json")) {
-            const gamesystemData = fs.readFileSync(gamesystemFile, 'utf-8');
-            return new StoreComponent_1.StoreComponent(gamesystemData, gamesystemFile, ModelComponentType_1.ModelComponentType.GAMESYTEM);
-        }
-    }
-}
-exports.GamesystemLoader = GamesystemLoader;
-//# sourceMappingURL=GamesystemLoader.js.map

app/storage/loader/GamesystemLoader.ts

@@ -1,44 +0,0 @@
-import {StoreComponent} from "../StoreComponent";
-import {FileUtils} from "../FileUtils";
-import * as fs from "fs";
-import * as path from "node:path";
-import {ModelComponentType} from "../../../src/app/project/game-model/ModelComponentType";
-
-export class GamesystemLoader {
-
-  gamesystemDir: string
-
-
-  constructor(gamesystemDir: string) {
-    this.gamesystemDir = gamesystemDir;
-  }
-
-  loadGamesystems() {
-    return this.loadGamesystemsRecursivly(this.gamesystemDir)
-  }
-
-  private loadGamesystemsRecursivly(currentGamesystemDir: string) {
-    let loadedGamesystems: StoreComponent[] = []
-    const gamesystemFiles = FileUtils.listFilesInDirectory(currentGamesystemDir);
-    gamesystemFiles.forEach(gamesystemFile => {
-      if(fs.lstatSync(gamesystemFile).isDirectory()) {
-        const childGamesystems = this.loadGamesystemsRecursivly(gamesystemFile);
-        loadedGamesystems = loadedGamesystems.concat(childGamesystems);
-      } else if(path.basename(gamesystemFile).endsWith(".json")) {
-        const loadedGamesystem = this.loadGamesystem(gamesystemFile);
-        if(loadedGamesystem != undefined) {
-          loadedGamesystems.push(loadedGamesystem);
-        }
-      }
-    })
-
-    return loadedGamesystems;
-  }
-
-  private loadGamesystem(gamesystemFile: string) {
-    if(gamesystemFile.endsWith(".json")) {
-      const gamesystemData = fs.readFileSync(gamesystemFile, 'utf-8');
-      return new StoreComponent(gamesystemData, gamesystemFile, ModelComponentType.GAMESYTEM);
-    }
-  }
-}

app/storage/loader/ScriptAccountLoader.js

@@ -1,31 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ScriptAccountLoader = void 0;
-const StoreComponent_1 = require("../StoreComponent");
-const FileUtils_1 = require("../FileUtils");
-const ModelComponentType_1 = require("../../../src/app/project/game-model/ModelComponentType");
-const fs = require("fs");
-class ScriptAccountLoader {
-    constructor(scriptAccountDir) {
-        this.scriptAccountDir = scriptAccountDir;
-    }
-    loadScriptAccounts() {
-        const scriptAccountFiles = FileUtils_1.FileUtils.listFilesInDirectory(this.scriptAccountDir);
-        const loadedScriptAccounts = [];
-        scriptAccountFiles.forEach(scriptAccountFile => {
-            const loadedScriptAccount = this.loadScriptAccount(scriptAccountFile);
-            if (loadedScriptAccount != undefined) {
-                loadedScriptAccounts.push(loadedScriptAccount);
-            }
-        });
-        return loadedScriptAccounts;
-    }
-    loadScriptAccount(scriptAccountFile) {
-        if (scriptAccountFile.endsWith(".json")) {
-            const scriptAccountData = fs.readFileSync(scriptAccountFile, 'utf-8');
-            return new StoreComponent_1.StoreComponent(scriptAccountData, scriptAccountFile, ModelComponentType_1.ModelComponentType.SCRIPTACCOUNT);
-        }
-    }
-}
-exports.ScriptAccountLoader = ScriptAccountLoader;
-//# sourceMappingURL=ScriptAccountLoader.js.map

app/storage/loader/ScriptAccountLoader.ts

@@ -1,34 +0,0 @@
-import {StoreComponent} from "../StoreComponent";
-import {FileUtils} from "../FileUtils";
-import {ModelComponentType} from "../../../src/app/project/game-model/ModelComponentType";
-import * as fs from "fs";
-import {ModelComponentFileDirectory} from "../ModelComponentFileDirectory";
-import {load} from "@angular-devkit/build-angular/src/utils/server-rendering/esm-in-memory-loader/loader-hooks";
-
-export class ScriptAccountLoader {
-  scriptAccountDir: string
-
-
-  constructor(scriptAccountDir: string) {
-    this.scriptAccountDir = scriptAccountDir;
-  }
-
-  loadScriptAccounts(): StoreComponent[] {
-    const scriptAccountFiles = FileUtils.listFilesInDirectory(this.scriptAccountDir);
-    const loadedScriptAccounts: StoreComponent[] = []
-    scriptAccountFiles.forEach(scriptAccountFile => {
-      const loadedScriptAccount = this.loadScriptAccount(scriptAccountFile);
-      if(loadedScriptAccount != undefined) {
-        loadedScriptAccounts.push(loadedScriptAccount)
-      }
-    })
-    return loadedScriptAccounts;
-  }
-
-  private loadScriptAccount(scriptAccountFile: string) {
-    if(scriptAccountFile.endsWith(".json")) {
-      const scriptAccountData = fs.readFileSync(scriptAccountFile, 'utf-8');
-      return new StoreComponent(scriptAccountData, scriptAccountFile, ModelComponentType.SCRIPTACCOUNT);
-    }
-  }
-}

app/storage/storing/GamesystemStorage.js

@@ -1,57 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.GamesystemStorage = void 0;
-const FileUtils_1 = require("../FileUtils");
-const path = require("node:path");
-const fs = require("fs");
-class GamesystemStorage {
-    constructor(gamesystemRootDir) {
-        this.gamesystemRootDir = gamesystemRootDir;
-    }
-    storeGamesystems(gamesystems) {
-        const unreferencedFiles = this.detectUnusedGamesystemFiles(gamesystems);
-        FileUtils_1.FileUtils.removeFiles(unreferencedFiles);
-        gamesystems.forEach(gamesystem => this.storeGamesystem(gamesystem));
-    }
-    detectUnusedGamesystemFiles(gamesystems) {
-        const unreferencedFiles = [];
-        const gamesystemFiles = FileUtils_1.FileUtils.listFilesInDirectory(this.gamesystemRootDir);
-        while (gamesystemFiles.length > 0) {
-            const currentGamesystemFile = gamesystemFiles.shift();
-            const referencedGamesystemName = path.parse(path.basename(currentGamesystemFile)).name;
-            const referencedGamesystem = this.findReferencedGamesystem(referencedGamesystemName, gamesystems);
-            if (referencedGamesystem == undefined) {
-                unreferencedFiles.push(currentGamesystemFile);
-            }
-            else {
-                const decodedJSONData = JSON.parse(referencedGamesystem.jsonString);
-                if (decodedJSONData.childsystems != undefined) {
-                    //Check if current file is a directory. When it is a directory, everything is fine
-                    if (fs.lstatSync(currentGamesystemFile).isDirectory()) {
-                    }
-                    else {
-                        const parentDirName = path.basename(path.dirname(currentGamesystemFile));
-                        if (parentDirName !== referencedGamesystemName) {
-                            unreferencedFiles.push(currentGamesystemFile);
-                        }
-                    }
-                }
-            }
-            if (fs.lstatSync(currentGamesystemFile).isDirectory()) {
-                gamesystemFiles.push(...FileUtils_1.FileUtils.listFilesInDirectory(currentGamesystemFile));
-            }
-        }
-        return unreferencedFiles;
-    }
-    findReferencedGamesystem(referencedName, gamesystems) {
-        return gamesystems.find(gamesystem => path.basename(gamesystem.fileName) === referencedName);
-    }
-    storeGamesystem(gamesystem) {
-        const gamesystemFile = path.join(...gamesystem.fileName.split("/"));
-        const completeGamesystemFile = path.join(this.gamesystemRootDir, gamesystemFile);
-        FileUtils_1.FileUtils.prepareFileForWriting(completeGamesystemFile);
-        fs.writeFileSync(completeGamesystemFile + ".json", gamesystem.jsonString, 'utf-8');
-    }
-}
-exports.GamesystemStorage = GamesystemStorage;
-//# sourceMappingURL=GamesystemStorage.js.map

app/storage/storing/GamesystemStorage.ts

@@ -1,64 +0,0 @@
-import {StoreComponent} from "../StoreComponent";
-import {FileUtils} from "../FileUtils";
-import * as path from "node:path";
-import * as fs from "fs";
-
-export class GamesystemStorage {
-
-  private gamesystemRootDir: string
-
-
-  constructor(gamesystemRootDir: string) {
-    this.gamesystemRootDir = gamesystemRootDir;
-  }
-
-  public storeGamesystems(gamesystems: StoreComponent[]) {
-    const unreferencedFiles = this.detectUnusedGamesystemFiles(gamesystems)
-    FileUtils.removeFiles(unreferencedFiles)
-    gamesystems.forEach(gamesystem => this.storeGamesystem(gamesystem))
-  }
-
-  private detectUnusedGamesystemFiles(gamesystems: StoreComponent[]) {
-    const unreferencedFiles: string[] = []
-    const gamesystemFiles = FileUtils.listFilesInDirectory(this.gamesystemRootDir);
-    while(gamesystemFiles.length > 0) {
-      const currentGamesystemFile = gamesystemFiles.shift()
-      const referencedGamesystemName = path.parse(path.basename(currentGamesystemFile!)).name
-      const referencedGamesystem = this.findReferencedGamesystem(referencedGamesystemName, gamesystems)
-      if(referencedGamesystem == undefined) {
-        unreferencedFiles.push(currentGamesystemFile!)
-      } else {
-        const decodedJSONData = JSON.parse(referencedGamesystem!.jsonString)
-        if(decodedJSONData.childsystems != undefined) {
-          //Check if current file is a directory. When it is a directory, everything is fine
-          if(fs.lstatSync(currentGamesystemFile!).isDirectory()) {
-
-          } else {
-            const parentDirName = path.basename(path.dirname(currentGamesystemFile!))
-            if(parentDirName !== referencedGamesystemName) {
-              unreferencedFiles.push(currentGamesystemFile!)
-            }
-          }
-        }
-      }
-
-      if(fs.lstatSync(currentGamesystemFile!).isDirectory()) {
-        gamesystemFiles.push(... FileUtils.listFilesInDirectory(currentGamesystemFile!))
-      }
-    }
-
-    return unreferencedFiles;
-  }
-
-  private findReferencedGamesystem(referencedName: string, gamesystems: StoreComponent[]): StoreComponent | undefined {
-    return gamesystems.find(gamesystem =>
-      path.basename(gamesystem.fileName) === referencedName)
-  }
-
-  private storeGamesystem(gamesystem: StoreComponent) {
-    const gamesystemFile = path.join(... gamesystem.fileName.split("/"))
-    const completeGamesystemFile = path.join(this.gamesystemRootDir, gamesystemFile)
-    FileUtils.prepareFileForWriting(completeGamesystemFile)
-    fs.writeFileSync(completeGamesystemFile + ".json", gamesystem.jsonString, 'utf-8')
-  }
-}

app/storage/storing/ScriptAccountStoring.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ScriptAccountStorage = void 0;
-const FileUtils_1 = require("../FileUtils");
-const path = require("node:path");
-const fs = require("fs");
-class ScriptAccountStorage {
-    constructor(scriptAccountDir) {
-        this.scriptAccountDir = scriptAccountDir;
-    }
-    storeScriptAccounts(scriptAccounts) {
-        this.persistDeletedScriptAccounts(scriptAccounts);
-        scriptAccounts.forEach(scriptAccount => {
-            this.storeScriptAccount(scriptAccount);
-        });
-    }
-    persistDeletedScriptAccounts(existingScriptAccount) {
-        const scriptAccountFiles = FileUtils_1.FileUtils.listFilesInDirectory(this.scriptAccountDir);
-        scriptAccountFiles.forEach(scriptAccountFile => {
-            const scriptAccountFileName = path.parse(path.basename(scriptAccountFile)).name;
-            if (existingScriptAccount.find(scriptAccount => scriptAccount.fileName === scriptAccountFileName) == undefined) {
-                //No scriptAccountFile was found with that nae of the file. So the scriptAccount was deleted. Remove file
-                fs.unlinkSync(scriptAccountFile);
-            }
-        });
-    }
-    storeScriptAccount(scriptAccount) {
-        const completeScriptAccountFile = path.join(this.scriptAccountDir, scriptAccount.fileName + ".json");
-        fs.writeFileSync(completeScriptAccountFile, scriptAccount.jsonString, 'utf-8');
-    }
-}
-exports.ScriptAccountStorage = ScriptAccountStorage;
-//# sourceMappingURL=ScriptAccountStoring.js.map

app/storage/storing/ScriptAccountStoring.ts

@@ -1,36 +0,0 @@
-import {StoreComponent} from "../StoreComponent";
-import {FileUtils} from "../FileUtils";
-import * as path from "node:path";
-import * as fs from "fs";
-
-export class ScriptAccountStorage {
-
-  private scriptAccountDir: string
-
-  constructor(scriptAccountDir: string) {
-    this.scriptAccountDir = scriptAccountDir;
-  }
-
-  storeScriptAccounts(scriptAccounts: StoreComponent[]) {
-    this.persistDeletedScriptAccounts(scriptAccounts)
-    scriptAccounts.forEach(scriptAccount => {
-      this.storeScriptAccount(scriptAccount)
-    })
-  }
-
-  private persistDeletedScriptAccounts(existingScriptAccount: StoreComponent[]) {
-    const scriptAccountFiles = FileUtils.listFilesInDirectory(this.scriptAccountDir);
-    scriptAccountFiles.forEach(scriptAccountFile => {
-      const scriptAccountFileName = path.parse(path.basename(scriptAccountFile)).name
-      if(existingScriptAccount.find(scriptAccount => scriptAccount.fileName === scriptAccountFileName) == undefined) {
-        //No scriptAccountFile was found with that nae of the file. So the scriptAccount was deleted. Remove file
-        fs.unlinkSync(scriptAccountFile)
-      }
-    })
-  }
-
-  private storeScriptAccount(scriptAccount: StoreComponent) {
-    const completeScriptAccountFile = path.join(this.scriptAccountDir, scriptAccount.fileName + ".json")
-    fs.writeFileSync(completeScriptAccountFile, scriptAccount.jsonString, 'utf-8')
-  }
-}

e2e/game-model/AddingGamesystems.spec.ts

@@ -1,8 +1,8 @@
 import { BrowserContext, ElectronApplication, Page, _electron as electron } from 'playwright';
 import { test, expect } from '@playwright/test';
 import * as PATH from 'path';
-import {GameModel} from "../../src/app/project/game-model/GameModel";
+import {GameModel} from "../../src/app/game-model/GameModel";
-import {Gamesystem} from "../../src/app/project/game-model/gamesystems/Gamesystem";
+import {Gamesystem} from "../../src/app/game-model/gamesystems/Gamesystem";
 
 test.describe('Adding Gamesystems', () => {
 

e2e/game-model/RemovingGamesystems.spec.ts

@@ -1,9 +1,8 @@
 import { BrowserContext, ElectronApplication, Page, _electron as electron } from 'playwright';
 import { test, expect } from '@playwright/test';
 import * as PATH from 'path';
-
+import {GameModel} from "../../src/app/game-model/GameModel";
-import {Gamesystem} from "../../src/app/project/game-model/gamesystems/Gamesystem";
+import {Gamesystem} from "../../src/app/game-model/gamesystems/Gamesystem";
-import {GameModel} from "../../src/app/project/game-model/GameModel";
 
 test.describe('Removing Gamesystems', () => {
 

e2e/game-model/gamesystems/CreateGamesystem.spec.ts

@@ -1,6 +1,15 @@
+import { BrowserContext, ElectronApplication, Page, _electron as electron } from 'playwright';
 import { test, expect } from '@playwright/test';
+import * as PATH from 'path';
+import {GameModel} from "../../../src/app/game-model/GameModel";
+import {Gamesystem} from "../../src/app/game-model/gamesystems/Gamesystem";
+import {ScriptAccount} from "../../../src/app/game-model/scriptAccounts/ScriptAccount";
+import {ModelComponentType} from "../../../src/app/game-model/ModelComponentType";
+import {SimpleGamesystem} from "../../../src/app/game-model/gamesystems/SimpleGamesystem";
+import exp = require("node:constants");
+import {end} from "electron-debug";
 import {GamesystemTrainer} from "./GamesystemTrainer";
-import {ProductGamesystem} from "../../../src/app/project/game-model/gamesystems/ProductGamesystem";
+import {ProductGamesystem} from "../../../src/app/game-model/gamesystems/ProductGamesystem";
 test.describe('Test Create Gamesystems', () => {
 
   test('Test creating gamesystem with invalid name', async => {

e2e/game-model/gamesystems/FindGamesystem.spec.ts

@@ -1,6 +1,13 @@
+import { BrowserContext, ElectronApplication, Page, _electron as electron } from 'playwright';
 import { test, expect } from '@playwright/test';
-import {GameModel} from "../../../src/app/project/game-model/GameModel";
+import * as PATH from 'path';
-import {SimpleGamesystem} from "../../../src/app/project/game-model/gamesystems/SimpleGamesystem";
+import {GameModel} from "../../../src/app/game-model/GameModel";
+import {Gamesystem} from "../../src/app/game-model/gamesystems/Gamesystem";
+import {ScriptAccount} from "../../../src/app/game-model/scriptAccounts/ScriptAccount";
+import {ModelComponentType} from "../../../src/app/game-model/ModelComponentType";
+import {SimpleGamesystem} from "../../../src/app/game-model/gamesystems/SimpleGamesystem";
+import exp = require("node:constants");
+import {end} from "electron-debug";
 import {GamesystemTrainer} from "./GamesystemTrainer";
 test.describe('Test Find Gamesystems', () => {
   const GAMEMODELNAME: string = "GameModel";

e2e/game-model/gamesystems/GamesystemTrainer.ts

@@ -1,6 +1,6 @@
-import {GameModel} from "../../../src/app/project/game-model/GameModel";
+import {GameModel} from "../../../src/app/game-model/GameModel";
-import {SimpleGamesystem} from "../../../src/app/project/game-model/gamesystems/SimpleGamesystem";
+import {SimpleGamesystem} from "../../../src/app/game-model/gamesystems/SimpleGamesystem";
-import {ProductGamesystem} from "../../../src/app/project/game-model/gamesystems/ProductGamesystem";
+import {ProductGamesystem} from "../../../src/app/game-model/gamesystems/ProductGamesystem";
 
 export class GamesystemTrainer {
 

e2e/game-model/gamesystems/SimpleGamesystem.spec.ts

@@ -1,5 +1,13 @@
+import { BrowserContext, ElectronApplication, Page, _electron as electron } from 'playwright';
 import { test, expect } from '@playwright/test';
-import {SimpleGamesystem} from "../../../src/app/project/game-model/gamesystems/SimpleGamesystem";
+import * as PATH from 'path';
+import {GameModel} from "../../../src/app/game-model/GameModel";
+import {Gamesystem} from "../../src/app/game-model/gamesystems/Gamesystem";
+import {ScriptAccount} from "../../../src/app/game-model/scriptAccounts/ScriptAccount";
+import {ModelComponentType} from "../../../src/app/game-model/ModelComponentType";
+import {SimpleGamesystem} from "../../../src/app/game-model/gamesystems/SimpleGamesystem";
+import exp = require("node:constants");
+import {end} from "electron-debug";
 
 test.describe('Test SimpleGamesystem', () => {
 

e2e/game-model/gamesystems/actions/AddActions.spec.ts

@@ -2,8 +2,8 @@
 import { test, expect } from '@playwright/test';
 import {GamesystemTrainer} from "../GamesystemTrainer";
 import {SimpleActionTrainer} from "./SimpleActionTrainer";
-import {ScriptAccount} from "../../../../src/app/project/game-model/scriptAccounts/ScriptAccount";
+import {ScriptAccount} from "../../../../src/app/game-model/scriptAccounts/ScriptAccount";
-import {ScriptAccountAction} from "../../../../src/app/project/game-model/gamesystems/actions/ScriptAccountAction";
+import {ScriptAccountAction} from "../../../../src/app/game-model/gamesystems/actions/ScriptAccountAction";
 test.describe('Test Create SimpleActions', () => {
 
   test('Test creating gamesystem with invalid name', async => {

e2e/game-model/gamesystems/actions/RemoveActions.spec.ts

@@ -2,9 +2,9 @@
 import { test, expect } from '@playwright/test';
 import {GamesystemTrainer} from "../GamesystemTrainer";
 import {SimpleActionTrainer} from "./SimpleActionTrainer";
-import {ScriptAccount} from "../../../../src/app/project/game-model/scriptAccounts/ScriptAccount";
+import {ScriptAccount} from "../../../../src/app/game-model/scriptAccounts/ScriptAccount";
-import {ScriptAccountAction} from "../../../../src/app/project/game-model/gamesystems/actions/ScriptAccountAction";
+import {ScriptAccountAction} from "../../../../src/app/game-model/gamesystems/actions/ScriptAccountAction";
-import {SimpleTransition} from "../../../../src/app/project/game-model/gamesystems/transitions/SimpleTransition";
+import {SimpleTransition} from "../../../../src/app/game-model/gamesystems/transitions/SimpleTransition";
 test.describe('Test Remove SimpleActions', () => {
 
   test("Test Removing invalid Actions", async () => {

e2e/game-model/gamesystems/actions/SimpleActionTrainer.ts

@@ -1,8 +1,8 @@
-import {SimpleState} from "../../../../src/app/project/game-model/gamesystems/states/SimpleState";
+import {SimpleState} from "../../../../src/app/game-model/gamesystems/states/SimpleState";
-import {SimpleTransition} from "../../../../src/app/project/game-model/gamesystems/transitions/SimpleTransition";
+import {SimpleTransition} from "../../../../src/app/game-model/gamesystems/transitions/SimpleTransition";
 import {Script} from "node:vm";
-import {ScriptAccount} from "../../../../src/app/project/game-model/scriptAccounts/ScriptAccount";
+import {ScriptAccount} from "../../../../src/app/game-model/scriptAccounts/ScriptAccount";
-import {ScriptAccountAction} from "../../../../src/app/project/game-model/gamesystems/actions/ScriptAccountAction";
+import {ScriptAccountAction} from "../../../../src/app/game-model/gamesystems/actions/ScriptAccountAction";
 
 export class SimpleActionTrainer {
   static withEmptyActions() {

e2e/game-model/gamesystems/conditions/AddTransitionConditions.spec.ts

@@ -1,7 +1,7 @@
 
 import { test, expect } from '@playwright/test';
-import {ScriptAccountCondition} from "../../../../src/app/project/game-model/gamesystems/conditions/ScriptAccountCondition";
+import {ScriptAccountCondition} from "../../../../src/app/game-model/gamesystems/conditions/ScriptAccountCondition";
-import {ScriptAccount} from "../../../../src/app/project/game-model/scriptAccounts/ScriptAccount";
+import {ScriptAccount} from "../../../../src/app/game-model/scriptAccounts/ScriptAccount";
 import exp = require("node:constants");
 import {ConditionTrainer} from "./ConditionTrainer";
 import {Conditional} from "@angular/compiler";

e2e/game-model/gamesystems/conditions/ConditionContradicting.spec.ts

@@ -1,7 +1,7 @@
 
 import { test, expect } from '@playwright/test';
-import {ScriptAccountCondition} from "../../../../src/app/project/game-model/gamesystems/conditions/ScriptAccountCondition";
+import {ScriptAccountCondition} from "../../../../src/app/game-model/gamesystems/conditions/ScriptAccountCondition";
-import {ScriptAccount} from "../../../../src/app/project/game-model/scriptAccounts/ScriptAccount";
+import {ScriptAccount} from "../../../../src/app/game-model/scriptAccounts/ScriptAccount";
 import exp = require("node:constants");
 import {ConditionTrainer} from "./ConditionTrainer";
 import {Conditional} from "@angular/compiler";

e2e/game-model/gamesystems/conditions/ConditionCreation.spec.ts

@@ -1,7 +1,7 @@
 
 import { test, expect } from '@playwright/test';
-import {ScriptAccountCondition} from "../../../../src/app/project/game-model/gamesystems/conditions/ScriptAccountCondition";
+import {ScriptAccountCondition} from "../../../../src/app/game-model/gamesystems/conditions/ScriptAccountCondition";
-import {ScriptAccount} from "../../../../src/app/project/game-model/scriptAccounts/ScriptAccount";
+import {ScriptAccount} from "../../../../src/app/game-model/scriptAccounts/ScriptAccount";
 import exp = require("node:constants");
 test.describe('Test Create Gamesystems', () => {
 

e2e/game-model/gamesystems/conditions/ConditionExpansion.spec.ts

@@ -1,7 +1,7 @@
 
 import { test, expect } from '@playwright/test';
-import {ScriptAccountCondition} from "../../../../src/app/project/game-model/gamesystems/conditions/ScriptAccountCondition";
+import {ScriptAccountCondition} from "../../../../src/app/game-model/gamesystems/conditions/ScriptAccountCondition";
-import {ScriptAccount} from "../../../../src/app/project/game-model/scriptAccounts/ScriptAccount";
+import {ScriptAccount} from "../../../../src/app/game-model/scriptAccounts/ScriptAccount";
 import exp = require("node:constants");
 import {ConditionTrainer} from "./ConditionTrainer";
 test.describe('Test Expand Conditions', () => {

e2e/game-model/gamesystems/conditions/ConditionTrainer.ts

@@ -1,5 +1,5 @@
-import {ScriptAccount} from "../../../../src/app/project/game-model/scriptAccounts/ScriptAccount";
+import {ScriptAccount} from "../../../../src/app/game-model/scriptAccounts/ScriptAccount";
-import {ScriptAccountCondition} from "../../../../src/app/project/game-model/gamesystems/conditions/ScriptAccountCondition";
+import {ScriptAccountCondition} from "../../../../src/app/game-model/gamesystems/conditions/ScriptAccountCondition";
 
 export class ConditionTrainer {
   static withSimpleCondition(): ScriptAccountCondition {

e2e/game-model/gamesystems/conditions/TransitionConditionTrainer.ts

@@ -1,7 +1,7 @@
-import {SimpleState} from "../../../../src/app/project/game-model/gamesystems/states/SimpleState";
+import {SimpleState} from "../../../../src/app/game-model/gamesystems/states/SimpleState";
-import {SimpleTransition} from "../../../../src/app/project/game-model/gamesystems/transitions/SimpleTransition";
+import {SimpleTransition} from "../../../../src/app/game-model/gamesystems/transitions/SimpleTransition";
-import {ScriptAccount} from "../../../../src/app/project/game-model/scriptAccounts/ScriptAccount";
+import {ScriptAccount} from "../../../../src/app/game-model/scriptAccounts/ScriptAccount";
-import {ScriptAccountCondition} from "../../../../src/app/project/game-model/gamesystems/conditions/ScriptAccountCondition";
+import {ScriptAccountCondition} from "../../../../src/app/game-model/gamesystems/conditions/ScriptAccountCondition";
 export class TransitionConditionTrainer {
   static withTransitionWithoutConditions() {
     const startingState = new SimpleState("StartingState", "");

e2e/game-model/gamesystems/productGamesystems/CreateProductStates.spec.ts

@@ -1,6 +1,17 @@
+import { BrowserContext, ElectronApplication, Page, _electron as electron } from 'playwright';
 import { test, expect } from '@playwright/test';
+import * as PATH from 'path';
+import {GameModel} from "../../../src/app/game-model/GameModel";
+import {Gamesystem} from "../../src/app/game-model/gamesystems/Gamesystem";
+import {ScriptAccount} from "../../../src/app/game-model/scriptAccounts/ScriptAccount";
+import {ModelComponentType} from "../../../src/app/game-model/ModelComponentType";
+import {SimpleGamesystem} from "../../../src/app/game-model/gamesystems/SimpleGamesystem";
+import exp = require("node:constants");
+import {end} from "electron-debug";
+import {GamesystemTrainer} from "./GamesystemTrainer";
+import {ProductGamesystem} from "../../../src/app/game-model/gamesystems/ProductGamesystem";
 import {ProductStateTrainer} from "./ProductStateTrainer";
-import {SimpleState} from "../../../../src/app/project/game-model/gamesystems/states/SimpleState";
+import {SimpleState} from "../../../../src/app/game-model/gamesystems/states/SimpleState";
 test.describe('Test Create ProductStates', () => {
 
   test("Adding already existent ProductState", async () => {

e2e/game-model/gamesystems/productGamesystems/CreateProductTransitions.spec.ts

@@ -1,7 +1,7 @@
 import { test, expect } from '@playwright/test';
 import {ProductStateTrainer} from "./ProductStateTrainer";
-import {ProductState} from "../../../../src/app/project/game-model/gamesystems/states/ProductState";
+import {ProductState} from "../../../../src/app/game-model/gamesystems/states/ProductState";
-import {SimpleGamesystem} from "../../../../src/app/project/game-model/gamesystems/SimpleGamesystem";
+import {SimpleGamesystem} from "../../../../src/app/game-model/gamesystems/SimpleGamesystem";
 test.describe('Test Create ProductTransitions', () => {
   test("Test ProductTransition Creation with invalid inputs", async ()=> {
     const gamesystem = ProductStateTrainer.givenFullProductGamesystemWithTwoStates();

e2e/game-model/gamesystems/productGamesystems/EqualInnerStates.spec.ts

@@ -1,5 +1,17 @@
+import { BrowserContext, ElectronApplication, Page, _electron as electron } from 'playwright';
 import { test, expect } from '@playwright/test';
+import * as PATH from 'path';
+import {GameModel} from "../../../src/app/game-model/GameModel";
+import {Gamesystem} from "../../src/app/game-model/gamesystems/Gamesystem";
+import {ScriptAccount} from "../../../src/app/game-model/scriptAccounts/ScriptAccount";
+import {ModelComponentType} from "../../../src/app/game-model/ModelComponentType";
+import {SimpleGamesystem} from "../../../src/app/game-model/gamesystems/SimpleGamesystem";
+import exp = require("node:constants");
+import {end} from "electron-debug";
+import {GamesystemTrainer} from "./GamesystemTrainer";
+import {ProductGamesystem} from "../../../src/app/game-model/gamesystems/ProductGamesystem";
 import {ProductStateTrainer} from "./ProductStateTrainer";
+import {SimpleState} from "../../../../src/app/game-model/gamesystems/states/SimpleState";
 test.describe('Test Check Equal of Innerstates', () => {
 
   test("Test invalid input for equal checking", async()=> {

e2e/game-model/gamesystems/productGamesystems/ProductStateGeneration.spec.ts

@@ -1,4 +1,17 @@
+import { BrowserContext, ElectronApplication, Page, _electron as electron } from 'playwright';
 import { test, expect } from '@playwright/test';
+import * as PATH from 'path';
+import {GameModel} from "../../../src/app/game-model/GameModel";
+import {Gamesystem} from "../../src/app/game-model/gamesystems/Gamesystem";
+import {ScriptAccount} from "../../../src/app/game-model/scriptAccounts/ScriptAccount";
+import {ModelComponentType} from "../../../src/app/game-model/ModelComponentType";
+import {SimpleGamesystem} from "../../../src/app/game-model/gamesystems/SimpleGamesystem";
+import exp = require("node:constants");
+import {end} from "electron-debug";
+import {GamesystemTrainer} from "./GamesystemTrainer";
+import {ProductGamesystem} from "../../../src/app/game-model/gamesystems/ProductGamesystem";
+import {ProductStateTrainer} from "./ProductStateTrainer";
+import {SimpleState} from "../../../../src/app/game-model/gamesystems/states/SimpleState";
 import {ProductSystemGenerationTrainer} from "./ProductSystemGenerationTrainer";
 test.describe('Test Create ProductStates', () => {
 

e2e/game-model/gamesystems/productGamesystems/ProductStateTrainer.ts

@@ -1,7 +1,7 @@
-import {ProductGamesystem} from "../../../../src/app/project/game-model/gamesystems/ProductGamesystem";
+import {ProductGamesystem} from "../../../../src/app/game-model/gamesystems/ProductGamesystem";
-import {SimpleGamesystem} from "../../../../src/app/project/game-model/gamesystems/SimpleGamesystem";
+import {SimpleGamesystem} from "../../../../src/app/game-model/gamesystems/SimpleGamesystem";
-import {ProductState} from "../../../../src/app/project/game-model/gamesystems/states/ProductState";
+import {ProductState} from "../../../../src/app/game-model/gamesystems/states/ProductState";
-import {ProductTransition} from "../../../../src/app/project/game-model/gamesystems/transitions/ProductTransition";
+import {ProductTransition} from "../../../../src/app/game-model/gamesystems/transitions/ProductTransition";
 
 export class ProductStateTrainer {
   static INNERSTATE_LETTER_1 = "A";

e2e/game-model/gamesystems/productGamesystems/ProductSystemGenerationTrainer.ts

@@ -1,5 +1,5 @@
-import {ProductGamesystem} from "../../../../src/app/project/game-model/gamesystems/ProductGamesystem";
+import {ProductGamesystem} from "../../../../src/app/game-model/gamesystems/ProductGamesystem";
-import {SimpleGamesystem} from "../../../../src/app/project/game-model/gamesystems/SimpleGamesystem";
+import {SimpleGamesystem} from "../../../../src/app/game-model/gamesystems/SimpleGamesystem";
 
 export class ProductSystemGenerationTrainer {
 

e2e/game-model/scriptAccounts/ScriptAccountTest.spec.ts

@@ -1,10 +1,10 @@
 import { BrowserContext, ElectronApplication, Page, _electron as electron } from 'playwright';
 import { test, expect } from '@playwright/test';
 import * as PATH from 'path';
-import {GameModel} from "../../../src/app/project/game-model/GameModel";
+import {GameModel} from "../../../src/app/game-model/GameModel";
-import {Gamesystem} from "../../src/app/project/game-model/gamesystems/Gamesystem";
+import {Gamesystem} from "../../src/app/game-model/gamesystems/Gamesystem";
-import {ScriptAccount} from "../../../src/app/project/game-model/scriptAccounts/ScriptAccount";
+import {ScriptAccount} from "../../../src/app/game-model/scriptAccounts/ScriptAccount";
-import {ModelComponentType} from "../../../src/app/project/game-model/ModelComponentType";
+import {ModelComponentType} from "../../../src/app/game-model/ModelComponentType";
 
 test.describe('Test ScriptAccounts', () => {
 

src/app/app.component.ts

@@ -1,25 +1,23 @@
 import {Component, NgZone, OnInit, ViewChild} from '@angular/core';
+import {ElectronService} from './core/services';
+import {APP_CONFIG} from '../environments/environment';
+import {ModelComponentType} from "./game-model/ModelComponentType";
 import {MatDrawerContainer} from "@angular/material/sidenav";
+import {ModelComponentTypeUtillities} from "./game-model/ModelComponentTypeUtillities";
+import {GameModel} from "./game-model/GameModel";
 import {EditorComponent} from "./editor/editor.component";
+import {ModelComponent} from "./game-model/ModelComponent";
 import {
   ScriptAccountOverviewComponent
 } from "./side-overviews/script-account-overview/script-account-overview.component";
 import {MatDialog} from "@angular/material/dialog";
 import {DeleteConfirmationDialogComponent} from "./delete-confirmation-dialog/delete-confirmation-dialog.component";
+import {ScriptAccount} from "./game-model/scriptAccounts/ScriptAccount";
 import {GamescriptOverviewComponent} from "./side-overviews/gamescript-overview/gamescript-overview.component";
-import {ModelComponentType} from "./project/game-model/ModelComponentType";
+import {LoadedProject} from "../../app/LoadedProject";
-import {ModelComponentTypeUtillities} from "./project/game-model/ModelComponentTypeUtillities";
+import {ProcessLoadedProject} from "./game-model/fs/ProcessLoadedProject";
-import {ScriptAccount} from "./project/game-model/scriptAccounts/ScriptAccount";
+import {StoreProject} from "./game-model/fs/store/StoreProject";
-import {Gamesystem} from "./project/game-model/gamesystems/Gamesystem";
+import {Gamesystem} from "./game-model/gamesystems/Gamesystem";
-import {ModelComponent} from "./project/game-model/ModelComponent";
-import {GameModel} from "./project/game-model/GameModel";
-import {StoredGameModel} from "../../app/storage/StoredGameModel";
-import {GamesystemParser} from "./project/parser/gamesystemParser/GamesystemParser";
-import {ScriptAccountParser} from "./project/parser/ScriptAccountParser";
-import {ElectronService} from "./core/services";
-import {ScriptAccountSerializer} from "./project/serializer/ScriptAccountSerializer";
-import {StoreComponent} from "../../app/storage/StoreComponent";
-import {GamesystemSerializer} from "./project/serializer/GamesystemSerializer";
 
 @Component({
   selector: 'app-root',
@@ -37,10 +35,20 @@ export class AppComponent implements OnInit{
   gameModel: GameModel | undefined
 
   constructor(private electronService: ElectronService,
-              private dialog: MatDialog,
+              private zone: NgZone,
-              private zone: NgZone
+              private dialog: MatDialog
   ) {
+    console.log('APP_CONFIG', APP_CONFIG);
+    if(this.gameModel == undefined)  {
+      this.gameModel = new GameModel("Unknown GameModel")
+    }
+
     if (electronService.isElectron) {
+      console.log(process.env);
+      console.log('Run in electron');
+      console.log('Electron ipcRenderer', this.electronService.ipcRenderer);
+      console.log('NodeJS childProcess', this.electronService.childProcess);
+
       electronService.ipcRenderer.on('context-menu', (event: any, message: string) => {
         this.zone.run(() => {
           this.onContextMenuMessageRecieved(message);
@@ -49,20 +57,23 @@ export class AppComponent implements OnInit{
 
       electronService.ipcRenderer.on('get-project-data', (event: any, message: string) => {
         this.zone.run(() => {
-          this.onSaveProject();
+          this.saveGameModel();
         })
       })
 
-      electronService.ipcRenderer.on('open-project', (event: any, loadedProject: StoredGameModel) => {
+      electronService.ipcRenderer.on('open-project', (event: any, loadedProject: LoadedProject) => {
-        this.zone.run(() => {
+        this.gameModel = ProcessLoadedProject.processLoadedProject(loadedProject)
-          this.onLoadProject(loadedProject)
       })
-      })
+    } else {
-
+      console.log('Run in browser');
-
     }
   }
 
+  saveGameModel() {
+    const storageModels = StoreProject.storeProject(this.gameModel!);
+    this.electronService.ipcRenderer.send('save-model', storageModels)
+  }
+
   onContextMenuMessageRecieved(message: string) {
     if(message == "edit") {
       this.onEditModelComponent();
@@ -104,10 +115,8 @@ export class AppComponent implements OnInit{
       if(res != undefined && res) {
         if(affectedModelComponent instanceof ScriptAccount) {
           this.gameModel!.removeScriptAccount(affectedModelComponent);
-          //this.electronService.ipcRenderer.send('delete-component', new DeleteModel(affectedModelComponent.componentName, ModelComponentType.SCRIPTACCOUNT))
         } else if(affectedModelComponent instanceof Gamesystem) {
           this.gameModel!.removeGamesystem(affectedModelComponent);
-          //this.electronService.ipcRenderer.send('delete-component', new DeleteModel(affectedModelComponent.componentName, ModelComponentType.GAMESYTEM))
           this.gamesystemOverview!.refresh()
         }
       }
@@ -149,13 +158,13 @@ export class AppComponent implements OnInit{
   private getSelectedModelComponent(): ModelComponent | undefined {
     if(this.openContent == ModelComponentType.SCRIPTACCOUNT) {
       if(this.scriptAccountOverview != undefined) {
-        return this.scriptAccountOverview.selectedScriptAccount;
+        return this.scriptAccountOverview!.selectedScriptAccount;
       } else {
         console.log("[WARN] [App.component] ScriptAccountOverview is undefined")
       }
     } else if(this.openContent == ModelComponentType.GAMESYTEM){
       if(this.gamesystemOverview != undefined) {
-        return this.gamesystemOverview.getSelectedGamesystem()
+        return this.gamesystemOverview!.getSelectedGamesystem()
       } else {
         console.log("[WARN] [App.component] GamesystemOverview is undefined")
       }
@@ -164,36 +173,29 @@ export class AppComponent implements OnInit{
   }
 
   ngOnInit() {
+    /*this.gameModel = new GameModel("No More");
+    this.gameModel.createScriptAccount("Temperature");
+    this.gameModel.createScriptAccount("Luftfeuchtigkeit");
 
-  }
+    const weather = new SimpleGamesystem("Weather");
+    const season = new SimpleGamesystem("Season");
 
-  onLoadProject(storedGameModel: StoredGameModel) {
+    const springState = season.createState("Spring", "Spring, also known as springtime, is one of the four temperate seasons, succeeding winter and preceding summer.");
-    const gameModel = new GameModel(storedGameModel.gameModelName)
+    const summerState = season.createState("Summer", "Summer is the hottest and brightest of the four temperate seasons, occurring after spring and before autumn. ");
 
-    const scriptAccounts = ScriptAccountParser.parseScriptAccounts(storedGameModel.storedScriptAccounts);
+    const sunnyState = weather.createState("Sunny", "The sun is shining. No clouds, no rain, no storm.");
+    const rainingState = weather.createState("Raining", "It rains")
 
-    const gamesystemParser = new GamesystemParser(scriptAccounts);
+    season.createTransition(springState!, summerState!);
-    const gamesystems = gamesystemParser.parseStoredGamesystems(storedGameModel.storedGamesystems);
+    weather.createTransition(sunnyState!, rainingState!);
 
-    gameModel.scriptAccounts = scriptAccounts
+    const weather_season = new ProductGamesystem("Weather-Season");
-    gameModel.gamesystems = gamesystems
+    weather_season.addChildGamesystem(weather);
-    gameModel.generateProductSystemContents()
+    weather_season.addChildGamesystem(season);
 
-    console.log(gameModel.scriptAccounts)
+    weather_season.createState([springState!, sunnyState!]);
 
-    this.gameModel = gameModel;
+    this.gameModel.addGamesystem(weather_season);*/
-  }
-
-  onSaveProject() {
-   if(this.gameModel != undefined) {
-     const storedScriptAccounts = ScriptAccountSerializer.serializeScriptAccounts(this.gameModel.scriptAccounts)
-     const storedGamesystems: StoreComponent[] =     GamesystemSerializer.serializeGamesystems(this.gameModel.gamesystems)
-     const storeModel = new StoredGameModel(this.gameModel.gameModelName, storedScriptAccounts, storedGamesystems)
-
-     if(this.electronService.isElectron) {
-       this.electronService.ipcRenderer.send('save-model', storeModel)
-     }
-   }
   }
 
   openScriptAccountsOverview() {

src/app/delete-confirmation-dialog/delete-confirmation-dialog.component.ts

@@ -1,24 +1,19 @@
-import {Component, Inject, OnInit} from '@angular/core';
+import {Component, Inject} from '@angular/core';
 import {MAT_DIALOG_DATA, MatDialogRef} from "@angular/material/dialog";
-import {ModelComponent} from "../project/game-model/ModelComponent";
+import {ModelComponentTypeUtillities} from "../game-model/ModelComponentTypeUtillities";
-import {ModelComponentTypeUtillities} from "../project/game-model/ModelComponentTypeUtillities";
+import {ModelComponent} from "../game-model/ModelComponent";
-
 
 @Component({
   selector: 'app-delete-confirmation-dialog',
   templateUrl: './delete-confirmation-dialog.component.html',
   styleUrl: './delete-confirmation-dialog.component.scss'
 })
-export class DeleteConfirmationDialogComponent implements OnInit{
+export class DeleteConfirmationDialogComponent {
 
   constructor(private dialogRef: MatDialogRef<DeleteConfirmationDialogComponent>,
               @Inject(MAT_DIALOG_DATA) public deleteModelComponent: ModelComponent) {
   }
-
+  protected readonly ModelComponentTypeUtillities = ModelComponentTypeUtillities;
-  ngOnInit(): void {
-    console.log("delete Confirmation dialog here")
-  }
-
 
   cancel() {
     this.dialogRef.close(false);
@@ -27,6 +22,4 @@ export class DeleteConfirmationDialogComponent implements OnInit{
   confirmDelete() {
     this.dialogRef.close(true);
   }
-
-  protected readonly ModelComponentTypeUtillities = ModelComponentTypeUtillities;
 }

src/app/editor/editor.component.ts

@@ -1,12 +1,11 @@
 import {Component, EventEmitter, Input, Output} from '@angular/core';
-import {ModelComponent} from "../project/game-model/ModelComponent";
+import {GameModel} from "../game-model/GameModel";
-import {GameModel} from "../project/game-model/GameModel";
+import {ModelComponent} from "../game-model/ModelComponent";
-import {ScriptAccount} from "../project/game-model/scriptAccounts/ScriptAccount";
+import {ModelComponentType} from "../game-model/ModelComponentType";
-import {Gamesystem} from "../project/game-model/gamesystems/Gamesystem";
+import {ScriptAccount} from "../game-model/scriptAccounts/ScriptAccount";
-import {State} from "../project/game-model/gamesystems/states/State";
+import {Gamesystem} from "../game-model/gamesystems/Gamesystem";
-import {Transition} from "../project/game-model/gamesystems/transitions/Transition";
+import {State} from "../game-model/gamesystems/states/State";
-import {ModelComponentType} from "../project/game-model/ModelComponentType";
+import {Transition} from "../game-model/gamesystems/transitions/Transition";
-
 
 @Component({
   selector: 'app-editor',
@@ -44,10 +43,9 @@ export class EditorComponent {
     }
   }
 
+  protected readonly ModelComponentType = ModelComponentType;
 
   onModelNameUpdate() {
     this.onModelNameUpdateEmitter.emit(true);
   }
-
-  protected readonly ModelComponentType = ModelComponentType;
 }

src/app/editor/gamesystem-editor/gamesystem-editor.component.ts

@@ -1,10 +1,11 @@
 import {Component, EventEmitter, Input, OnInit, Output} from '@angular/core';
-import {State} from "../../project/game-model/gamesystems/states/State";
+import {GameModel} from "../../game-model/GameModel";
-import {Gamesystem} from "../../project/game-model/gamesystems/Gamesystem";
+import {Gamesystem} from "../../game-model/gamesystems/Gamesystem";
-import { Transition } from '../../project/game-model/gamesystems/transitions/Transition';
+import {State} from "../../game-model/gamesystems/states/State";
-import {ScriptAccount} from "../../project/game-model/scriptAccounts/ScriptAccount";
+import {Transition} from "../../game-model/gamesystems/transitions/Transition";
-import {SimpleGamesystem} from "../../project/game-model/gamesystems/SimpleGamesystem";
+import {SimpleGamesystem} from "../../game-model/gamesystems/SimpleGamesystem";
-import {ProductGamesystem} from "../../project/game-model/gamesystems/ProductGamesystem";
+import {ProductGamesystem} from "../../game-model/gamesystems/ProductGamesystem";
+import {ScriptAccount} from "../../game-model/scriptAccounts/ScriptAccount";
 
 @Component({
   selector: 'app-gamesystem-editor',

src/app/editor/gamesystem-editor/product-gamesystem-editor/LeafGamesystemCalculator.ts

@@ -1,9 +1,9 @@
-import {Gamesystem} from "../../../project/game-model/gamesystems/Gamesystem";
+import {Gamesystem} from "../../../game-model/gamesystems/Gamesystem";
-import {SimpleGamesystem} from "../../../project/game-model/gamesystems/SimpleGamesystem";
+import {SimpleGamesystem} from "../../../game-model/gamesystems/SimpleGamesystem";
-import {ProductGamesystem} from "../../../project/game-model/gamesystems/ProductGamesystem";
+import {ProductGamesystem} from "../../../game-model/gamesystems/ProductGamesystem";
-import {State} from "../../../project/game-model/gamesystems/states/State";
+import {State} from "../../../game-model/gamesystems/states/State";
-import {SimpleState} from "../../../project/game-model/gamesystems/states/SimpleState";
+import {ProductState} from "../../../game-model/gamesystems/states/ProductState";
-import {ProductState} from "../../../project/game-model/gamesystems/states/ProductState";
+import {SimpleState} from "../../../game-model/gamesystems/states/SimpleState";
 
 export class LeafGamesystemCalculator {
 

src/app/editor/gamesystem-editor/product-gamesystem-editor/product-gamesystem-editor.component.ts

@@ -1,9 +1,10 @@
 import {Component, EventEmitter, Input, Output} from '@angular/core';
+import {ProductGamesystem} from "../../../game-model/gamesystems/ProductGamesystem";
+import {ProductStateEditorComponent} from "../state-editor/product-state-editor/product-state-editor.component";
+import {SimpleGamesystem} from "../../../game-model/gamesystems/SimpleGamesystem";
 import {
   ProductTransitionEditorComponent
 } from "../transition-editor/product-transition-editor/product-transition-editor.component";
-import {ProductGamesystem} from "../../../project/game-model/gamesystems/ProductGamesystem";
-import {SimpleGamesystem} from "../../../project/game-model/gamesystems/SimpleGamesystem";
 
 
 

src/app/editor/gamesystem-editor/scriptaccount-condition-editor/scriptaccount-condition-editor.component.ts

@@ -1,7 +1,7 @@
 import {Component, EventEmitter, Input, OnInit, Output} from '@angular/core';
+import {ScriptAccountCondition} from "../../../game-model/gamesystems/conditions/ScriptAccountCondition";
 import {MatTableDataSource} from "@angular/material/table";
-import {ScriptAccountCondition} from "../../../project/game-model/gamesystems/conditions/ScriptAccountCondition";
+import {ScriptAccount} from "../../../game-model/scriptAccounts/ScriptAccount";
-import {ScriptAccount} from "../../../project/game-model/scriptAccounts/ScriptAccount";
 
 @Component({
   selector: 'app-scriptaccount-condition-editor',

src/app/editor/gamesystem-editor/simple-gamesystem-editor/simple-gamesystem-editor.component.ts

@@ -1,7 +1,7 @@
 import {Component, Input} from '@angular/core';
+import {SimpleGamesystem} from "../../../game-model/gamesystems/SimpleGamesystem";
 import {MatTableDataSource} from "@angular/material/table";
-import {SimpleGamesystem} from "../../../project/game-model/gamesystems/SimpleGamesystem";
+import {ScriptAccount} from "../../../game-model/scriptAccounts/ScriptAccount";
-import {ScriptAccount} from "../../../project/game-model/scriptAccounts/ScriptAccount";
 
 @Component({
   selector: 'app-simple-gamesystem-editor',

src/app/editor/gamesystem-editor/state-editor/product-state-editor/product-state-editor.component.ts

@@ -1,13 +1,15 @@
 import {Component, EventEmitter, Input, OnInit, Output} from '@angular/core';
+import {ProductGamesystem} from "../../../../game-model/gamesystems/ProductGamesystem";
+import {SimpleGamesystem} from "../../../../game-model/gamesystems/SimpleGamesystem";
 import {
   MatTableDataSource
 } from "@angular/material/table";
+import {SimpleState} from "../../../../game-model/gamesystems/states/SimpleState";
+import {State} from "../../../../game-model/gamesystems/states/State";
 import {LeafGamesystemCalculator} from "../../product-gamesystem-editor/LeafGamesystemCalculator";
+import {ProductTransition} from "../../../../game-model/gamesystems/transitions/ProductTransition";
+import {ProductState} from "../../../../game-model/gamesystems/states/ProductState";
 import {animate, state, style, transition, trigger} from "@angular/animations";
-import {ProductGamesystem} from "../../../../project/game-model/gamesystems/ProductGamesystem";
-import {SimpleGamesystem} from "../../../../project/game-model/gamesystems/SimpleGamesystem";
-import {ProductState} from "../../../../project/game-model/gamesystems/states/ProductState";
-import {State} from "../../../../project/game-model/gamesystems/states/State";
 
 @Component({
   selector: 'app-product-state-editor',
@@ -53,6 +55,7 @@ export class ProductStateEditorComponent implements OnInit{
     })
   }
 
+  protected readonly SimpleState = SimpleState;
 
   getLeafState(state: State<any>, i: number) {
     return LeafGamesystemCalculator.calcLeafStates(state)[i];

src/app/editor/gamesystem-editor/state-editor/simple-state-editor/simple-state-editor.component.ts

@@ -1,11 +1,13 @@
 import {Component, Input, OnInit} from '@angular/core';
+import {SimpleState} from "../../../../game-model/gamesystems/states/SimpleState";
 import {MatTableDataSource} from "@angular/material/table";
 import {animate, state, style, transition, trigger} from "@angular/animations";
 import {MatSnackBar} from "@angular/material/snack-bar";
-import {SimpleState} from "../../../../project/game-model/gamesystems/states/SimpleState";
+import {SimpleGamesystem} from "../../../../game-model/gamesystems/SimpleGamesystem";
-import {SimpleGamesystem} from "../../../../project/game-model/gamesystems/SimpleGamesystem";
+import {ProductState} from "../../../../game-model/gamesystems/states/ProductState";
-import {ScriptAccount} from "../../../../project/game-model/scriptAccounts/ScriptAccount";
+import {LeafGamesystemCalculator} from "../../product-gamesystem-editor/LeafGamesystemCalculator";
-import {ScriptAccountCondition} from "../../../../project/game-model/gamesystems/conditions/ScriptAccountCondition";
+import {ScriptAccount} from "../../../../game-model/scriptAccounts/ScriptAccount";
+import {ScriptAccountCondition} from "../../../../game-model/gamesystems/conditions/ScriptAccountCondition";
 
 @Component({
   selector: 'app-simple-state-editor',

src/app/editor/gamesystem-editor/transition-editor/product-transition-editor/product-transition-editor.component.ts

@@ -1,13 +1,13 @@
 import {Component, EventEmitter, Input, OnInit, Output} from '@angular/core';
+import {ProductGamesystem} from "../../../../game-model/gamesystems/ProductGamesystem";
+import {SimpleGamesystem} from "../../../../game-model/gamesystems/SimpleGamesystem";
 import {
   MatTableDataSource
 } from "@angular/material/table";
 import {LeafGamesystemCalculator} from "../../product-gamesystem-editor/LeafGamesystemCalculator";
+import {ProductTransition} from "../../../../game-model/gamesystems/transitions/ProductTransition";
+import {ProductState} from "../../../../game-model/gamesystems/states/ProductState";
 import {animate, state, style, transition, trigger} from "@angular/animations";
-import {ProductGamesystem} from "../../../../project/game-model/gamesystems/ProductGamesystem";
-import {SimpleGamesystem} from "../../../../project/game-model/gamesystems/SimpleGamesystem";
-import {ProductTransition} from "../../../../project/game-model/gamesystems/transitions/ProductTransition";
-import {ProductState} from "../../../../project/game-model/gamesystems/states/ProductState";
 class DisplayedColumnName {
   displayedName: string
   internalName: string

src/app/editor/gamesystem-editor/transition-editor/scriptaccount-action-editor/scriptaccount-action-editor.component.ts

@@ -1,8 +1,8 @@
 import {Component, Input, OnInit} from '@angular/core';
+import {Transition} from "../../../../game-model/gamesystems/transitions/Transition";
 import {MatTableDataSource} from "@angular/material/table";
-import {ScriptAccount} from "../../../../project/game-model/scriptAccounts/ScriptAccount";
+import {ScriptAccountAction} from "../../../../game-model/gamesystems/actions/ScriptAccountAction";
-import {Transition} from "../../../../project/game-model/gamesystems/transitions/Transition";
+import {ScriptAccount} from "../../../../game-model/scriptAccounts/ScriptAccount";
-import {ScriptAccountAction} from "../../../../project/game-model/gamesystems/actions/ScriptAccountAction";
 
 @Component({
   selector: 'app-scriptaccount-action-editor',

src/app/editor/gamesystem-editor/transition-editor/simple-transition-editor/simple-transition-editor.component.ts

@@ -1,13 +1,13 @@
 import {Component, Input, OnInit} from '@angular/core';
+import {SimpleGamesystem} from "../../../../game-model/gamesystems/SimpleGamesystem";
 import {
   MatTableDataSource
 } from "@angular/material/table";
+import {SimpleTransition} from "../../../../game-model/gamesystems/transitions/SimpleTransition";
 import {animate, state, style, transition, trigger} from "@angular/animations";
-import {SimpleGamesystem} from "../../../../project/game-model/gamesystems/SimpleGamesystem";
+import {SimpleState} from "../../../../game-model/gamesystems/states/SimpleState";
-import {ScriptAccount} from "../../../../project/game-model/scriptAccounts/ScriptAccount";
+import {ScriptAccount} from "../../../../game-model/scriptAccounts/ScriptAccount";
-import {SimpleTransition} from "../../../../project/game-model/gamesystems/transitions/SimpleTransition";
+import {ScriptAccountCondition} from "../../../../game-model/gamesystems/conditions/ScriptAccountCondition";
-import {SimpleState} from "../../../../project/game-model/gamesystems/states/SimpleState";
-import {ScriptAccountCondition} from "../../../../project/game-model/gamesystems/conditions/ScriptAccountCondition";
 @Component({
   selector: 'app-simple-transition-editor',
   templateUrl: './simple-transition-editor.component.html',

src/app/editor/model-component-editor/model-component-editor.component.ts

@@ -1,6 +1,6 @@
 import {Component, EventEmitter, Input, OnInit, Output} from '@angular/core';
+import {ModelComponent} from "../../game-model/ModelComponent";
 import {FormControl, Validators} from "@angular/forms";
-import {ModelComponent} from "../../project/game-model/ModelComponent";
 
 @Component({
   selector: 'app-model-component-editor',

src/app/editor/script-account-editor/script-account-editor.component.ts

@@ -1,12 +1,12 @@
 import {Component, Input, OnInit} from '@angular/core';
-
+import {ScriptAccount} from "../../game-model/scriptAccounts/ScriptAccount";
+import {ModelComponent} from "../../game-model/ModelComponent";
 import {MatFormField} from "@angular/material/form-field";
 import {MatInput} from "@angular/material/input";
 import {FormControl, FormGroupDirective, FormsModule, NgForm, Validators} from "@angular/forms";
 import {NgIf} from "@angular/common";
 import {ErrorStateMatcher} from "@angular/material/core";
 import {ElectronService} from "../../core/services";
-import {ScriptAccount} from "../../project/game-model/scriptAccounts/ScriptAccount";
 
 export class MyErrorStateMatcher implements ErrorStateMatcher {
   isErrorState(control: FormControl | null, form: FormGroupDirective | NgForm | null): boolean {

src/app/game-model/GameModel.ts

@@ -7,27 +7,37 @@ import {SimpleGamesystem} from "./gamesystems/SimpleGamesystem";
 import {StorageModel} from "./fs/StorageModel";
 
 export class GameModel {
-  gameModelName: string
+  private readonly _gameModelName: string
 
-  gamesystems: Gamesystem<any, any>[] = [];
+  private _gamesystems: Gamesystem<any, any>[] = [];
-  scriptAccounts: ScriptAccount[] = [];
+  private _scriptAccounts: ScriptAccount[] = [];
 
   constructor(gameModelName: string) {
-    this.gameModelName = gameModelName;
+    this._gameModelName = gameModelName;
+  }
+  get gameModelName(): string {
+    return this._gameModelName;
+  }
+  get gamesystems(): Gamesystem<any, any>[] {
+    return this._gamesystems;
+  }
+  get scriptAccounts(): ScriptAccount[] {
+    return this._scriptAccounts;
   }
 
   addGamesystem(gamesystem: Gamesystem<any, any>) {
     if(this.findGamesystem(gamesystem.componentName) == undefined) {
-      this.gamesystems.push(gamesystem);
+      this._gamesystems.push(gamesystem);
     }
 
   }
 
   removeGamesystem(gamesystem : Gamesystem<any, any>) {
     if(gamesystem.parentGamesystem == undefined) {
-      this.gamesystems = this.gamesystems.filter(g => g !== gamesystem);
+      this._gamesystems = this._gamesystems.filter(g => g !== gamesystem);
     } else {
       (gamesystem.parentGamesystem as ProductGamesystem).removeChildGamesystem(gamesystem);
+      console.log(gamesystem.parentGamesystem)
     }
   }
 
@@ -67,7 +77,7 @@ export class GameModel {
 
   removeScriptAccount(scriptAccount: ScriptAccount) {
     if(scriptAccount != undefined) {
-      this.scriptAccounts = this.scriptAccounts.filter(s => s != scriptAccount);
+      this._scriptAccounts = this.scriptAccounts.filter(s => s != scriptAccount);
     }
   }
 
@@ -89,12 +99,4 @@ export class GameModel {
   addScriptAccount(scriptAccount: ScriptAccount) {
     this.scriptAccounts.push(scriptAccount);
   }
-
-  generateProductSystemContents() {
-    this.gamesystems.forEach(gamesystem => {
-      if(gamesystem instanceof ProductGamesystem) {
-        gamesystem.generateFromChildsystems();
-      }
-    })
-  }
 }

src/app/game-model/gamesystems/ProductGamesystem.ts

@@ -6,6 +6,7 @@ import {Transition} from "./transitions/Transition";
 import {SimpleState} from "./states/SimpleState";
 import {SimpleGamesystem} from "./SimpleGamesystem";
 import {GameModel} from "../GameModel";
+import {ProductStateTrainer} from "../../../../e2e/game-model/gamesystems/productGamesystems/ProductStateTrainer";
 import {ScriptAccountCondition} from "./conditions/ScriptAccountCondition";
 import {ScriptAccountAction} from "./actions/ScriptAccountAction";
 
@@ -20,14 +21,12 @@ export class ProductGamesystem extends Gamesystem<ProductState, ProductTransitio
     if(simpleGamesystem.states.length > 0) {
       simpleGamesystem.componentName += "(Child)";
       productGamesystem.addChildGamesystem(simpleGamesystem);
-      simpleGamesystem.parentGamesystem = productGamesystem
     }
 
 
     if(parentGamesystem != undefined) {
       parentGamesystem.removeChildGamesystem(simpleGamesystem);
       parentGamesystem.addChildGamesystem(productGamesystem);
-      productGamesystem.parentGamesystem = parentGamesystem
     } else {
       gameModel.removeGamesystem(simpleGamesystem);
       gameModel.addGamesystem(productGamesystem);

src/app/project/game-model/fs/DeleteModel.ts

@@ -1,12 +0,0 @@
-import {ModelComponentType} from "../ModelComponentType";
-
-export class DeleteModel {
-  componentName: string
-  modeltype: ModelComponentType
-
-
-  constructor(componentName: string, modeltype: ModelComponentType) {
-    this.componentName = componentName;
-    this.modeltype = modeltype;
-  }
-}

src/app/project/parser/ScriptAccountParser.ts

@@ -1,20 +0,0 @@
-import {StoreComponent} from "../../../../app/storage/StoreComponent";
-import {ScriptAccount} from "../game-model/scriptAccounts/ScriptAccount";
-
-export class ScriptAccountParser {
-
-  public static parseScriptAccounts(storedScriptAccounts: StoreComponent[]): ScriptAccount[] {
-    const scriptAccounts: ScriptAccount[] = []
-    storedScriptAccounts.forEach(scriptAccount => {
-      scriptAccounts.push(this.parseScriptAccount(scriptAccount))
-    })
-    return scriptAccounts;
-  }
-
-  private static parseScriptAccount(storedComponent: StoreComponent): ScriptAccount {
-    console.log("Parse ScriptAccount: ", storedComponent.fileName)
-    const parsedScriptAccount = new ScriptAccount("", "");
-    Object.assign(parsedScriptAccount, JSON.parse(storedComponent.jsonString));
-    return parsedScriptAccount;
-  }
-}

src/app/project/parser/gamesystemParser/GamesystemParser.ts

@@ -1,87 +0,0 @@
-import {StoreComponent} from "../../../../../app/storage/StoreComponent";
-import {Gamesystem} from "../../game-model/gamesystems/Gamesystem";
-import {ParsedParentGamesystems} from "./ParsedParentGamesystems";
-import {ProductGamesystem} from "../../game-model/gamesystems/ProductGamesystem";
-import {SimpleGamesystem} from "../../game-model/gamesystems/SimpleGamesystem";
-import {StateParser} from "./StateParser";
-import {ScriptAccount} from "../../game-model/scriptAccounts/ScriptAccount";
-import {TransitionParser} from "./TransitionParser";
-
-export class GamesystemParser {
-
-  private parsedParentGamesystems: ParsedParentGamesystems[] = []
-  private parsedGamesystems: Gamesystem<any, any>[] = []
-
-  private scriptAccounts: ScriptAccount[]
-
-
-  constructor(scriptAccounts: ScriptAccount[]) {
-    this.scriptAccounts = scriptAccounts;
-  }
-
-
-  public parseStoredGamesystems(storedGamesystems: StoreComponent[]): Gamesystem<any, any>[] {
-    storedGamesystems.forEach(storedGamesystem => {
-      this.parseGamesystem(storedGamesystem)
-    })
-
-    return this.computeGamesystemStructure();
-  }
-
-  private parseGamesystem(storedGamesystem: StoreComponent) {
-    const parsedGamesystemData = JSON.parse(storedGamesystem.jsonString)
-    let parsedSystem: Gamesystem<any, any>
-    if(parsedGamesystemData.childsystems != undefined) {
-      parsedSystem = this.parseProductGamesystem(parsedGamesystemData)
-    } else {
-      parsedSystem = this.parseSimpleGamesystem(parsedGamesystemData)
-    }
-    this.parsedGamesystems.push(parsedSystem);
-  }
-
-  parseSimpleGamesystem(gamesystemData: any): SimpleGamesystem {
-    const simpleGamesystem = new SimpleGamesystem(gamesystemData.componentName, gamesystemData.componentDescription)
-
-    const stateParser = new StateParser(this.scriptAccounts);
-    simpleGamesystem.states = stateParser.parseStates(gamesystemData.states)
-
-    const transitionParser = new TransitionParser(simpleGamesystem.states, this.scriptAccounts)
-    simpleGamesystem.transitions = transitionParser.parseTransitions(gamesystemData.transitions)
-    return simpleGamesystem
-  }
-
-  parseProductGamesystem(gamesystemData: any) {
-    const productGamesystem = new ProductGamesystem(gamesystemData.componentName, gamesystemData.componentDescription);
-    const childsystemNames: string[] = []
-    for(let i=0; i<gamesystemData.childsystems.length; i++) {
-      childsystemNames.push(gamesystemData.childsystems[i].componentName)
-    }
-    this.parsedParentGamesystems.push(new ParsedParentGamesystems(productGamesystem, childsystemNames))
-
-    return productGamesystem;
-  }
-
-  private computeGamesystemStructure(): Gamesystem<any, any>[] {
-    const topGamesystems: Gamesystem<any, any>[] = []
-    this.parsedGamesystems.forEach(parsedGamesystem => {
-      const searchedParentsystem = this.findParentsystem(parsedGamesystem.componentName)
-      if(searchedParentsystem != undefined) {
-        searchedParentsystem.addChildGamesystem(parsedGamesystem)
-        parsedGamesystem.parentGamesystem = searchedParentsystem
-      } else {
-        topGamesystems.push(parsedGamesystem)
-      }
-    })
-    return topGamesystems
-  }
-
-  findParentsystem(childsystemName: string) {
-    for(let i=0; i<this.parsedParentGamesystems.length; i++) {
-      if(this.parsedParentGamesystems[i].childsystemNames.includes(childsystemName)) {
-        return this.parsedParentGamesystems[i].parentGamesystem;
-      }
-    }
-    return undefined
-  }
-
-}

src/app/project/parser/gamesystemParser/ParsedParentGamesystems.ts

@@ -1,12 +0,0 @@
-import {ProductGamesystem} from "../../game-model/gamesystems/ProductGamesystem";
-
-export class ParsedParentGamesystems {
-  parentGamesystem: ProductGamesystem
-  childsystemNames: string[]
-
-
-  constructor(parentGamesystem: ProductGamesystem, childsystemNames: string[]) {
-    this.parentGamesystem = parentGamesystem;
-    this.childsystemNames = childsystemNames;
-  }
-}

src/app/project/parser/gamesystemParser/ScriptAccountConditionParser.ts

@@ -1,39 +0,0 @@
-import {ScriptAccount} from "../../game-model/scriptAccounts/ScriptAccount";
-import {ScriptAccountCondition} from "../../game-model/gamesystems/conditions/ScriptAccountCondition";
-import {max, min} from "rxjs";
-
-export class ScriptAccountConditionParser {
-
-  private scriptAccounts: ScriptAccount[]
-
-
-  constructor(scriptAccounts: ScriptAccount[]) {
-    this.scriptAccounts = scriptAccounts;
-  }
-
-  parseStoredConditions(conditionData: any): ScriptAccountCondition[] {
-    const conditions: ScriptAccountCondition[]  = []
-    for(let i=0; i<conditionData.length; i++) {
-      const parsedCondition = this.parseSingleCondition(conditionData[i]);
-      if(parsedCondition != undefined) {
-        conditions.push(parsedCondition)
-      }
-    }
-    return conditions
-  }
-
-  private parseSingleCondition(conditionData: any): ScriptAccountCondition | undefined{
-    const referencedScriptAccount = this.findScriptAccountByName(conditionData.scriptAccount);
-    if(referencedScriptAccount != undefined) {
-      const minValue = conditionData.minValue;
-      const maxValue = conditionData.maxValue;
-      return ScriptAccountCondition.constructScriptAccountCondition(referencedScriptAccount, minValue, maxValue);
-    } else {
-      return undefined;
-    }
-  }
-
-  private findScriptAccountByName(scriptAccountName: string) {
-    return this.scriptAccounts.find(scriptAccount => scriptAccount.componentName === scriptAccountName);
-  }
-}

src/app/project/parser/gamesystemParser/StateParser.ts

@@ -1,39 +0,0 @@
-import {SimpleState} from "../../game-model/gamesystems/states/SimpleState";
-import {ScriptAccount} from "../../game-model/scriptAccounts/ScriptAccount";
-import {ScriptAccountCondition} from "../../game-model/gamesystems/conditions/ScriptAccountCondition";
-import {ScriptAccountConditionParser} from "./ScriptAccountConditionParser";
-
-export class StateParser {
-
-    private conditionParser
-
-
-    constructor(scriptAccounts: ScriptAccount[]) {
-      this.conditionParser = new ScriptAccountConditionParser(scriptAccounts)
-    }
-
-    public  parseStates(stateData: any): SimpleState[] {
-      const parsedStates: SimpleState[] = []
-      for(let i=0; i<stateData.length; i++) {
-        parsedStates.push(this.parseState(stateData[i]))
-      }
-
-      return parsedStates;
-    }
-
-   private parseState(stateData: any): SimpleState {
-      const initial = stateData.initial
-      const stateLabel = stateData.stateLabel
-      const stateDescription = stateData.stateDescription
-
-      const conditions = this.conditionParser.parseStoredConditions(stateData.conditions)
-
-      const simpleState = new SimpleState(stateLabel, stateDescription);
-      simpleState.initial = initial;
-      simpleState.conditions = conditions;
-
-      return simpleState;
-   }
-
-
-}

src/app/project/parser/gamesystemParser/TransitionParser.ts

@@ -1,46 +0,0 @@
-import {SimpleState} from "../../game-model/gamesystems/states/SimpleState";
-import {ScriptAccountConditionParser} from "./ScriptAccountConditionParser";
-import {ScriptAccount} from "../../game-model/scriptAccounts/ScriptAccount";
-import {SimpleTransition} from "../../game-model/gamesystems/transitions/SimpleTransition";
-
-
-export class TransitionParser {
-
-  private states: SimpleState[]
-  private conditionParser: ScriptAccountConditionParser
-
-
-  constructor(states: SimpleState[], scriptAccounts: ScriptAccount[]) {
-    this.states = states;
-    this.conditionParser = new ScriptAccountConditionParser(scriptAccounts);
-  }
-
-  public parseTransitions(transitionData: any): SimpleTransition[] {
-    const transitions: SimpleTransition[] = []
-    for(let i=0; i<transitionData.length; i++) {
-      const parsedTransition = this.parseSingleTransition(transitionData[i]);
-      if(parsedTransition != undefined) {
-        transitions.push(parsedTransition)
-      }
-    }
-    return transitions
-  }
-
-  private parseSingleTransition(transitionData: any): SimpleTransition | undefined{
-    const startingState = this.findStateByLabel(transitionData.startingState)
-    const endingState = this.findStateByLabel(transitionData.endingState);
-
-    if(startingState == undefined || endingState == undefined) {
-      return undefined
-    }
-
-    const simpleTransition = new SimpleTransition(startingState, endingState)
-    simpleTransition.scriptAccountConditions = this.conditionParser.parseStoredConditions(transitionData.scriptAccountConditions)
-
-    return simpleTransition;
-  }
-
-  private findStateByLabel(stateLabel: string) {
-    return this.states.find(state => state.stateLabel === stateLabel);
-  }
-}

src/app/project/serializer/GamesystemSerializer.ts

@@ -1,109 +0,0 @@
-import {Gamesystem} from "../game-model/gamesystems/Gamesystem";
-import {StoreComponent} from "../../../../app/storage/StoreComponent";
-import {SimpleGamesystem} from "../game-model/gamesystems/SimpleGamesystem";
-import {ProductGamesystem} from "../game-model/gamesystems/ProductGamesystem";
-import {SerializeConstants} from "./SerializeConstants";
-import {ModelComponentType} from "../game-model/ModelComponentType";
-
-export class GamesystemSerializer {
-
-  private static IGNORED_SIMPLE_ATTRIBUTES  = ["parentGamesystem", 'incomingTransitions', "outgoingTransitions", "unsaved", "type"]
-
-  public static serializeGamesystems(gamesystems: Gamesystem<any, any>[]): StoreComponent[] {
-    let storedGamesystems: StoreComponent[] = []
-    gamesystems.forEach(gamesystem => storedGamesystems = storedGamesystems.concat(this.serializeSingleGamesystem(gamesystem)))
-    return storedGamesystems
-  }
-
-  private static serializeSingleGamesystem(gamesystem: Gamesystem<any, any>): StoreComponent[] {
-    if(gamesystem instanceof SimpleGamesystem) {
-      console.log("Simple Gamesystem")
-      return [this.serializeSimpleGamesystem(gamesystem as SimpleGamesystem)]
-    } else {
-      return this.serializeProductGamesystem(gamesystem as ProductGamesystem)
-    }
-  }
-
-  private static serializeSimpleGamesystem(simpleGamesystem: SimpleGamesystem): StoreComponent {
-    const fileName = this.computeSimpleGamesystemPath(simpleGamesystem);
-    if(simpleGamesystem.componentName === "Weather(Child)") {
-      console.log(fileName)
-    }
-    const jsonString = JSON.stringify(simpleGamesystem, (key, value) => {
-
-      if(this.IGNORED_SIMPLE_ATTRIBUTES.includes(key)) {
-        return undefined
-      } else if(key === 'startingState' || key === 'endingState') {
-        return value.stateLabel
-      } else if(key === 'scriptAccount') {
-        return value.componentName
-      } else {
-        return value;
-      }
-    }, SerializeConstants.JSON_INDENT)
-
-    return new StoreComponent(jsonString, fileName, ModelComponentType.GAMESYTEM)
-  }
-
-  private static serializeProductGamesystem(productGamesystem: ProductGamesystem): StoreComponent[] {
-    const storedGamesystems: StoreComponent[] = []
-
-    const fileName = this.computeProductGamesystemPath(productGamesystem)
-    const innerGamesystemJsonArray: {'componentName': string}[] = []
-    productGamesystem.innerGamesystems.forEach(innerGamesystem => {
-      innerGamesystemJsonArray.push({
-        'componentName': innerGamesystem.componentName
-      })
-
-      const storedChildsystems = this.serializeSingleGamesystem(innerGamesystem);
-      storedChildsystems.forEach(storedChildsystem => storedGamesystems.push(storedChildsystem))
-    })
-
-    const jsonString = {
-      'componentName': productGamesystem.componentName,
-      'componentDescription': productGamesystem.componentDescription,
-      'childsystems': innerGamesystemJsonArray
-    }
-
-    const storedProductsystem = new StoreComponent(JSON.stringify(jsonString), fileName, ModelComponentType.GAMESYTEM)
-    storedGamesystems.push(storedProductsystem)
-
-    return storedGamesystems;
-  }
-
-  private static computeSimpleGamesystemPath(simpleGamesystem: SimpleGamesystem): string {
-    if(simpleGamesystem.parentGamesystem == undefined) {
-      return simpleGamesystem.componentName
-    } else {
-      const pathElements: string[] = [simpleGamesystem.componentName]
-      let currentGamesystem: ProductGamesystem | undefined = simpleGamesystem.parentGamesystem
-      while(currentGamesystem != undefined) {
-        pathElements.unshift(currentGamesystem.componentName)
-        currentGamesystem = currentGamesystem.parentGamesystem
-      }
-      let output = ""
-      for(let i=0; i<pathElements.length; i++) {
-        output += pathElements[i] + "/"
-      }
-      return output.slice(0, -1)
-    }
-  }
-
-  private static computeProductGamesystemPath(productGamesystem: ProductGamesystem): string {
-    if(productGamesystem.parentGamesystem == undefined) {
-      return productGamesystem.componentName + "/" + productGamesystem.componentName
-    } else {
-      const pathElements: string[] = [productGamesystem.componentName + "/" + productGamesystem.componentName]
-      let currentGamesystem: ProductGamesystem | undefined = productGamesystem.parentGamesystem
-      while(currentGamesystem != undefined) {
-        pathElements.unshift(currentGamesystem.componentName)
-        currentGamesystem = currentGamesystem.parentGamesystem
-      }
-      let output = ""
-      for(let i=0; i<pathElements.length; i++) {
-        output += pathElements[i] + "/"
-      }
-      return output.slice(0, -1)
-    }
-  }
-}

src/app/project/serializer/ScriptAccountSerializer.ts

@@ -1,25 +0,0 @@
-import {ScriptAccount} from "../game-model/scriptAccounts/ScriptAccount";
-import {StoreComponent} from "../../../../app/storage/StoreComponent";
-import {SerializeConstants} from "./SerializeConstants";
-import {ModelComponentType} from "../game-model/ModelComponentType";
-
-export  class ScriptAccountSerializer {
-
-  public static serializeScriptAccounts(scriptAccounts: ScriptAccount[]): StoreComponent[] {
-    const storeComponents: StoreComponent[] = []
-    scriptAccounts.forEach(scriptAccount => storeComponents.push(this.serializeSingleScriptAccount(scriptAccount)))
-    return storeComponents;
-  }
-
-  private static serializeSingleScriptAccount(scriptAccount: ScriptAccount): StoreComponent {
-    const fileName = scriptAccount.componentName
-    const jsonString = JSON.stringify(scriptAccount, (key, value) => {
-      if(key === 'unsaved' || key === 'type') {
-        return undefined
-      } else {
-        return value;
-      }
-    }, SerializeConstants.JSON_INDENT)
-    return new StoreComponent(jsonString, fileName, ModelComponentType.SCRIPTACCOUNT);
-  }
-}

src/app/project/serializer/SerializeConstants.ts

@@ -1,3 +0,0 @@
-export class SerializeConstants {
-  public static JSON_INDENT = 4
-}

src/app/side-overviews/gamescript-overview/gamescript-overview.component.ts

@@ -1,13 +1,13 @@
 import {Component, EventEmitter, Input, OnInit, Output} from '@angular/core';
+import {Gamesystem} from "../../game-model/gamesystems/Gamesystem";
+import {State} from "../../game-model/gamesystems/states/State";
+import {Transition} from "../../game-model/gamesystems/transitions/Transition";
+import {ProductGamesystem} from "../../game-model/gamesystems/ProductGamesystem";
 import {FlatTreeControl} from "@angular/cdk/tree";
 import {MatTreeFlatDataSource, MatTreeFlattener} from "@angular/material/tree";
+import {SimpleGamesystem} from "../../game-model/gamesystems/SimpleGamesystem";
+import {GameModel} from "../../game-model/GameModel";
 import {ElectronService} from "../../core/services";
-import {GameModel} from "../../project/game-model/GameModel";
-import {Gamesystem} from "../../project/game-model/gamesystems/Gamesystem";
-import {State} from "../../project/game-model/gamesystems/states/State";
-import {Transition} from "../../project/game-model/gamesystems/transitions/Transition";
-import {ProductGamesystem} from "../../project/game-model/gamesystems/ProductGamesystem";
-import {SimpleGamesystem} from "../../project/game-model/gamesystems/SimpleGamesystem";
 
 
 interface FlatNode {