app/main.ts

@@ -76,12 +76,6 @@ function createWindow(): BrowserWindow {
               click: () => {
                 win!.webContents.send('context-menu', "new-gamesystem-character");
               }
-            },
-            {
-              label: "Character-Relation",
-              click: () => {
-                win!.webContents.send('context-menu', "new-gamesystem-character_relation");
-              }
             }
           ]
         },

src/app/app.component.ts

@@ -219,8 +219,7 @@ export class AppComponent implements OnInit{
     gameModel.generateProductSystemContents()
 
     const characterTemplateSystems = gameModel.getTemplateSystems(TemplateType.CHARACTER).map(templateSystem => templateSystem as SimpleTemplateGamesystem)
-    const characterRelationTemplateSystems = gameModel.getTemplateSystems(TemplateType.CHARACTER_RELATION).map(templateSystem => templateSystem as SimpleTemplateGamesystem)
+    const characterParser = new CharacterParser(characterTemplateSystems, gameModel.scriptAccounts);
-    const characterParser = new CharacterParser(characterTemplateSystems, characterRelationTemplateSystems, gameModel.scriptAccounts);
     gameModel.characters = characterParser.parseCharacters(storedGameModel.storedCharacters)
 
     this.gameModel = gameModel;

src/app/editor/character-editor/character-editor.component.html

@@ -14,45 +14,3 @@
     <button mat-stroked-button class="specify-btn" (click)="openTemplateSpecificator()">Specify Templatesystem</button>
   </mat-card-content>
 </mat-card>
-
-<mat-card>
-  <mat-card-header>
-    <mat-card-title>Characterrelationspecifc Gamesystems</mat-card-title>
-  </mat-card-header>
-  <mat-card-content>
-    <mat-accordion>
-      <mat-expansion-panel *ngFor="let templateSystem of character!.characterRelationGamesystems">
-        <mat-expansion-panel-header>
-          <mat-panel-title>{{templateSystem.componentName}}</mat-panel-title>
-        </mat-expansion-panel-header>
-        <app-gamesystem-editor [templateElement]="character" [gamesystem]="templateSystem" [scriptAccounts]="gameModel!.scriptAccounts"></app-gamesystem-editor>
-      </mat-expansion-panel>
-      <button mat-stroked-button class="specify-btn" (click)="openCharacterRelationTemplateSpecificator()">Specify Templatesystem</button>
-    </mat-accordion>
-  </mat-card-content>
-</mat-card>
-
-
-<mat-card>
-  <mat-card-header>
-    <mat-card-title>Character-Relations</mat-card-title>
-  </mat-card-header>
-  <mat-card-content>
-    <mat-accordion>
-      <mat-expansion-panel *ngFor="let characterRelation of character!.characterRelations">
-        <mat-expansion-panel-header>
-          <mat-panel-title>{{characterRelation.firstCharacter.componentName}} - {{characterRelation.secondCharacter.componentName}}</mat-panel-title>
-        </mat-expansion-panel-header>
-        <p>Templatesystems: {{characterRelation.characterRelationGamesystems.length}}</p>
-        <mat-accordion>
-          <mat-expansion-panel *ngFor="let templateSystem of characterRelation.characterRelationGamesystems">
-            <mat-expansion-panel-header>
-              <mat-panel-title>{{templateSystem.componentName}}</mat-panel-title>
-            </mat-expansion-panel-header>
-            <app-product-gamesystem-editor [gamesystem]="templateSystem" [templateElement]="characterRelation"></app-product-gamesystem-editor>
-          </mat-expansion-panel>
-        </mat-accordion>
-      </mat-expansion-panel>
-    </mat-accordion>
-  </mat-card-content>
-</mat-card>

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

@@ -29,12 +29,4 @@ export class CharacterEditorComponent {
     })
   }
 
-  openCharacterRelationTemplateSpecificator() {
-    const dialogRef = this.dialog.open(TemplateSpecificatorComponent, {data: this.gameModel!.getTemplateSystems(TemplateType.CHARACTER_RELATION), minWidth: "400px"});
-    dialogRef.afterClosed().subscribe(res => {
-      if(res != undefined) {
-        this.character!.addAsymetricCharacterRelationGamesystem(res);
-      }
-    })
-  }
 }

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

@@ -1,14 +1,3 @@
-
 <app-simple-gamesystem-editor *ngIf="isSimpleGamesystem()"  [templateElement]="templateElement" [simpleGamesystem]="convertGamesystemToSimpleGamesystem()" [scriptAccunts]="scriptAccounts"></app-simple-gamesystem-editor>
 <app-product-gamesystem-editor *ngIf="!isSimpleGamesystem()"  [templateElement]="templateElement" [gamesystem]="convertGamesystemToProductGamesystem()"
                                (onOpenGamesystemEditor)="onOpenGamesystemEditor($event)"></app-product-gamesystem-editor>
-
-<mat-expansion-panel *ngIf="gamesystem != undefined">
-  <mat-expansion-panel-header>
-    <mat-panel-title>Product Generation Settings</mat-panel-title>
-  </mat-expansion-panel-header>
-  <div *ngIf="isGamesystemTemplate()">
-    <mat-checkbox [(ngModel)]="convertGamesystemToTemplate(gamesystem)!.symmetric">Use symmetric Productgenerators</mat-checkbox>
-  </div>
-  <mat-checkbox [(ngModel)]="gamesystem!.generateIsolatedStates">Generate Isolated ProductStates</mat-checkbox>
-</mat-expansion-panel>

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

@@ -6,8 +6,6 @@ import {ScriptAccount} from "../../project/game-model/scriptAccounts/ScriptAccou
 import {SimpleGamesystem} from "../../project/game-model/gamesystems/SimpleGamesystem";
 import {ProductGamesystem} from "../../project/game-model/gamesystems/ProductGamesystem";
 import {TemplateElement} from "../../project/game-model/templates/TemplateElement";
-import {SimpleTemplateGamesystem} from "../../project/game-model/templates/simpleGamesystem/SimpleTemplateGamesystem";
-import {ProductTemplateSystem} from "../../project/game-model/templates/productGamesystem/ProductTemplateSystem";
 
 @Component({
   selector: 'app-gamesystem-editor',
@@ -44,19 +42,4 @@ export class GamesystemEditorComponent implements OnInit{
   onOpenGamesystemEditor(gamesystem: SimpleGamesystem) {
     this.openGamesystemEmitter.emit(gamesystem);
   }
-
-  isGamesystemTemplate() {
-    return this.gamesystem instanceof SimpleTemplateGamesystem || this.gamesystem instanceof ProductTemplateSystem;
-  }
-
-  convertGamesystemToTemplate(gamesystem: Gamesystem<State<any>, Transition<any>> | undefined) {
-    if(gamesystem instanceof SimpleTemplateGamesystem) {
-      return gamesystem as SimpleTemplateGamesystem;
-    } else if(gamesystem instanceof ProductTemplateSystem) {
-      return gamesystem as ProductTemplateSystem
-    } else {
-      return undefined
-    }
-
-  }
 }

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

@@ -1,4 +1,3 @@
-
 <app-product-state-editor [templateElement]="templateElement" [gamesystem]="gamesystem" (onOpenGamesystemEditor)="onOpenGamesystemEditor($event)"></app-product-state-editor>
 <div id="productStateEditor">
   <app-product-transition-editor [templateElement]="templateElement" [gamesystem]="gamesystem" (onOpenGamesystem)="onOpenGamesystemEditor($event)"></app-product-transition-editor>

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

@@ -1,4 +1,4 @@
-import {Component, EventEmitter, Input, OnInit, Output} from '@angular/core';
+import {Component, EventEmitter, Input, Output} from '@angular/core';
 import {
   ProductTransitionEditorComponent
 } from "../transition-editor/product-transition-editor/product-transition-editor.component";
@@ -13,15 +13,12 @@ import {TemplateElement} from "../../../project/game-model/templates/TemplateEle
   templateUrl: './product-gamesystem-editor.component.html',
   styleUrl: './product-gamesystem-editor.component.scss'
 })
-export class ProductGamesystemEditorComponent implements OnInit{
+export class ProductGamesystemEditorComponent {
 
   @Input() gamesystem: ProductGamesystem | undefined
   @Input() templateElement: TemplateElement | undefined
   @Output("onOpenGamesystemEditor") openGamesystemEditorEmitter = new EventEmitter<SimpleGamesystem>();
 
-  ngOnInit() {
-  }
-
   onOpenGamesystemEditor(gamesystem: SimpleGamesystem) {
     this.openGamesystemEditorEmitter.emit(gamesystem);
   }

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

@@ -5,8 +5,8 @@
       <input matInput (keyup)="applyFilter($event)" placeholder="Filter" #input>
     </mat-form-field>
     <table mat-table [dataSource]="datasource" class="mat-elevation-z8" multiTemplateDataRows>
-      <ng-container *ngFor="let col of internalColumnNames; let i = index" [matColumnDef]="col">
+      <ng-container *ngFor="let col of displayedColumns; let i = index" [matColumnDef]="col">
-        <th mat-header-cell *matHeaderCellDef>{{displayedColumns[i]}}</th>
+        <th mat-header-cell *matHeaderCellDef>{{col}}</th>
         <td mat-cell *matCellDef="let state">
           <a *ngIf="i < displayedColumns.length-1" role="button" (click)="clickOnInnerState(i)" [matTooltip]="getLeafState(state, i).stateDescription">{{getLeafState(state, i).stateLabel}}</a>
           <mat-icon *ngIf="i == displayedColumns.length-1">

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

@@ -29,8 +29,6 @@ export class ProductStateEditorComponent implements OnInit{
   @Input() templateElement: TemplateElement | undefined
   @Output('onOpenGamesystemEditor') openGamesystemEditorEmitter = new EventEmitter<SimpleGamesystem>();
   displayedColumns: string[] = [];
-  internalColumnNames: string[] = []
-
   expandedColumns: string[] = []
   datasource = new MatTableDataSource<ProductState>();
 
@@ -40,17 +38,11 @@ export class ProductStateEditorComponent implements OnInit{
     this.gamesystem!.generateFromChildsystems();
     this.generateColumnNamesRecursively(this.gamesystem!, "");
     this.displayedColumns.push('Initial');
-
+    this.expandedColumns = [...this.displayedColumns, 'expand'];
-    this.internalColumnNames = this.displayedColumns.concat();
-
-    this.renameDuplicateColumnNames(this.internalColumnNames)
-
-    this.expandedColumns = [...this.internalColumnNames, 'expand'];
 
     if(this.templateElement == undefined) {
       this.datasource.data = this.gamesystem!.states;
     } else if(this.gamesystem instanceof ProductTemplateSystem) {
-      console.log("Product Template System: ", this.gamesystem!.stateMap.get(this.templateElement))
       this.datasource.data = this.gamesystem!.stateMap.get(this.templateElement)!
     }
 
@@ -60,20 +52,6 @@ export class ProductStateEditorComponent implements OnInit{
     }
   }
 
-  private renameDuplicateColumnNames(columnNames: string[]) {
-    for(let i=0; i<columnNames.length; i++) {
-      for(let j=i; j<columnNames.length; j++) {
-        if(i === j) {
-          continue;
-        }
-
-        if(columnNames[i] === columnNames[j]) {
-          columnNames[j] = columnNames[j] + "-" + i
-        }
-      }
-    }
-  }
-
   generateColumnNamesRecursively(gamesystem: ProductGamesystem, nestedColumnName: string) {
     gamesystem.innerGamesystems.forEach(innerGamesystem => {
       if(innerGamesystem instanceof SimpleGamesystem) {

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

@@ -50,8 +50,6 @@ export class ProductTransitionEditorComponent implements OnInit{
       const leafGamesystems: SimpleGamesystem[] = LeafGamesystemCalculator.calcLeafGeamesystems(this.gamesystem);
       this.displayedColumns = leafGamesystems.map(leafGamesystem => new DisplayedColumnName(leafGamesystem.componentName, leafGamesystem.componentName + "-start"));
       this.displayedColumns = this.displayedColumns.concat( leafGamesystems.map(leafGamesystem => new DisplayedColumnName(leafGamesystem.componentName, leafGamesystem.componentName + "-end")));
-      this.renameDuplicateColumnNames(this.displayedColumns)
-
 
       this.numberLeafSystems = leafGamesystems.length;
       this.columns = this.displayedColumns.map(column => column.internalName)
@@ -74,20 +72,6 @@ export class ProductTransitionEditorComponent implements OnInit{
     }
   }
 
-  private renameDuplicateColumnNames(columnNames: DisplayedColumnName[]) {
-    for(let i=0; i<columnNames.length; i++) {
-      for(let j=i; j<columnNames.length; j++) {
-        if(i === j) {
-          continue;
-        }
-
-        if(columnNames[i].internalName === columnNames[j].internalName) {
-          columnNames[j].internalName = columnNames[j].internalName + "-" + i
-        }
-      }
-    }
-  }
-
   getLeafStateByIndex(transition: ProductTransition, leafIndex: number) {
     let state: ProductState;
     let index = leafIndex;

src/app/project/game-model/GameModel.ts

@@ -10,7 +10,6 @@ import {TemplateType} from "./templates/TemplateType";
 import {SimpleTemplateGamesystem} from "./templates/simpleGamesystem/SimpleTemplateGamesystem";
 import {ProductTemplateSystem} from "./templates/productGamesystem/ProductTemplateSystem";
 import {ProductTemplateCreator} from "./templates/productGamesystem/ProductTemplateCreator";
-import {CharacterRelation} from "./characters/CharacterRelation";
 
 export class GameModel {
   gameModelName: string
@@ -76,7 +75,6 @@ export class GameModel {
 
     let parentProductGamesystem: ProductGamesystem;
     if(parentGamesystem instanceof SimpleTemplateGamesystem) {
-      console.log("Simple Template")
       parentProductGamesystem = ProductTemplateCreator.constructTemplateFromSimpleGamesystem(parentGamesystem,  this, templateType!)
     } else if(parentGamesystem instanceof SimpleGamesystem) {
       if(simpleGamesystem instanceof SimpleTemplateGamesystem) {
@@ -129,21 +127,12 @@ export class GameModel {
     const searchedCharacter = this.characters.find(character => character.componentName === characterName);
     if(searchedCharacter == undefined) {
       const character = new Character(characterName, "");
-      this.createCharacterRelation(character)
       this.characters.push(character)
       return character
     }
     return undefined
   }
 
-  private createCharacterRelation(addedCharacter: Character) {
-    this.characters.forEach(character => {
-      const characterRelation = new CharacterRelation(character, addedCharacter);
-      character.addCharacterRelation(characterRelation);
-      addedCharacter.addCharacterRelation(characterRelation);
-    })
-  }
-
   removeScriptAccount(scriptAccount: ScriptAccount) {
     if(scriptAccount != undefined) {
       this.scriptAccounts = this.scriptAccounts.filter(s => s != scriptAccount);

src/app/project/game-model/characters/Character.ts

@@ -6,16 +6,11 @@ import {Gamesystem} from "../gamesystems/Gamesystem";
 import {SimpleTemplateGamesystem} from "../templates/simpleGamesystem/SimpleTemplateGamesystem";
 import {ProductTemplateSystem} from "../templates/productGamesystem/ProductTemplateSystem";
 import {ProductGamesystem} from "../gamesystems/ProductGamesystem";
-import {CharacterRelation} from "./CharacterRelation";
 
 export class Character extends ModelComponent implements TemplateElement {
 
   characterSpecificTemplateSystems: Gamesystem<any, any>[] = []
 
-  characterRelations: CharacterRelation[] = []
-
-  characterRelationGamesystems: Gamesystem<any, any>[] = []
-
   constructor(componentName: string, componentDescription: string) {
     super(componentName, componentDescription, ModelComponentType.CHARACTER);
   }
@@ -41,48 +36,8 @@ export class Character extends ModelComponent implements TemplateElement {
     }
   }
 
-  addAsymetricCharacterRelationGamesystem(gamesystem: Gamesystem<any, any>, recursiveCall: boolean = false) {
-    if(!this.isTemplateSystemCharacterRelationSpecific(gamesystem.componentName)) {
-      if(gamesystem instanceof SimpleTemplateGamesystem) {
-        this.characterRelationGamesystems.push(gamesystem);
-        gamesystem.addTemplateElement(this);
-        this.characterRelations.forEach(characterRelation => {
-          characterRelation.addCharacterRelationSystem(gamesystem)
-        })
-      } else if(gamesystem instanceof ProductTemplateSystem) {
-        this.characterRelationGamesystems.push(gamesystem);
-        gamesystem.addTemplateElement(this);
-        this.characterRelations.forEach(characterRelation => {
-          characterRelation.addCharacterRelationSystem(gamesystem)
-        })
-
-        if(!recursiveCall) {
-          gamesystem.innerGamesystems.forEach(innerGamesystem => this.addAsymetricCharacterRelationGamesystem(innerGamesystem, true))
-        }
-      }
-
-      if(gamesystem.parentGamesystem != undefined) {
-        this.addAsymetricCharacterRelationGamesystem(gamesystem.parentGamesystem, true)
-      }
-
-    } else {
-      console.log("Was already added")
-      console.log(this)
-    }
-  }
-
-  addCharacterRelation(characterRelation: CharacterRelation) {
-    this.characterRelations.push(characterRelation)
-  }
-
   private isTemplateSystemCharacterSpecific(gamesystemName: string) {
     return this.characterSpecificTemplateSystems.find(gamesystem => gamesystem.componentName === gamesystemName) != undefined
   }
 
-  private isTemplateSystemCharacterRelationSpecific(gamesystemName: string) {
-    return this.characterRelationGamesystems.find(gamesystem =>
-      gamesystem.componentName === gamesystemName) != undefined;
-
-  }
-
 }

src/app/project/game-model/characters/CharacterRelation.ts

@@ -1,38 +0,0 @@
-import {TemplateElement} from "../templates/TemplateElement";
-import {Character} from "./Character";
-import {ProductTemplateSystem} from "../templates/productGamesystem/ProductTemplateSystem";
-import {Gamesystem} from "../gamesystems/Gamesystem";
-import {SimpleTemplateGamesystem} from "../templates/simpleGamesystem/SimpleTemplateGamesystem";
-import {TemplateType} from "../templates/TemplateType";
-import {ProductTemplateCreator} from "../templates/productGamesystem/ProductTemplateCreator";
-
-export class CharacterRelation implements TemplateElement{
-
-  firstCharacter: Character
-  secondCharacter: Character
-
-  characterRelationGamesystems: ProductTemplateSystem[] = []
-
-  constructor(firstCharacter: Character, secondCharacter: Character) {
-    this.firstCharacter = firstCharacter;
-    this.secondCharacter = secondCharacter;
-  }
-
-  addCharacterRelationSystem(gamesystem: Gamesystem<any, any>) {
-    if((gamesystem instanceof SimpleTemplateGamesystem || gamesystem instanceof ProductTemplateSystem) && !this.isGamesystemCharacterRelationSpecific(gamesystem.componentName)) {
-       const templateGamesystem = new ProductTemplateSystem(gamesystem.componentName, gamesystem.componentDescription, TemplateType.CHARACTER_RELATION);
-       templateGamesystem.symmetric = gamesystem.symmetric
-       templateGamesystem.generateIsolatedStates = gamesystem.generateIsolatedStates
-       templateGamesystem.addChildGamesystem(gamesystem);
-       templateGamesystem.addChildGamesystem(gamesystem);
-       this.characterRelationGamesystems.push(templateGamesystem);
-       templateGamesystem.addTemplateElement(this);
-    } else {
-      console.log("Test")
-    }
-  }
-
-  private isGamesystemCharacterRelationSpecific(gamesystemName: string) {
-    return this.characterRelationGamesystems.find(gamesystem => gamesystem.componentName === gamesystemName) != undefined
-  }
-}

src/app/project/game-model/gamesystems/Gamesystem.ts

@@ -8,8 +8,6 @@ export abstract class Gamesystem<S, T> extends ModelComponent{
   states: S[] = [];
   transitions: T[] = [];
   parentGamesystem: ProductGamesystem | undefined
-  generateIsolatedStates: boolean = false
-
   constructor(gamesystemName: string, gamesystemDescription: string) {
    super(gamesystemName, gamesystemDescription, ModelComponentType.GAMESYTEM);
   }

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

@@ -11,7 +11,6 @@ import {ScriptAccountAction} from "./actions/ScriptAccountAction";
 import {ProductSystemGenerator} from "./productSystemGenerator/ProductSystemGenerator";
 import {TemplateType} from "../templates/TemplateType";
 import {ProductTemplateSystem} from "../templates/productGamesystem/ProductTemplateSystem";
-import {IsolatedProductStateGenerator} from "./productSystemGenerator/IsolatedProductStateGenerator";
 
 export class ProductGamesystem extends Gamesystem<ProductState, ProductTransition> {
 
@@ -75,11 +74,6 @@ export class ProductGamesystem extends Gamesystem<ProductState, ProductTransitio
   generateFromChildsystems() {
     const productGenerator = new ProductSystemGenerator(this);
     productGenerator.generateFromChildsystems();
-
-    if(this.generateIsolatedStates) {
-      const isolatedStatesGenerator = new IsolatedProductStateGenerator(this);
-      isolatedStatesGenerator.generateIsolatedProductStates();
-    }
   }
 
   addChildGamesystem(gamesystem: Gamesystem<State<any>, Transition<any>>) {

src/app/project/game-model/gamesystems/productSystemGenerator/IsolatedProductStateGenerator.ts

@@ -1,54 +0,0 @@
-import {ProductSystemGenerator} from "./ProductSystemGenerator";
-import {ProductGenerationData} from "./ProductGenerationData";
-import {ProductGeneratorResult} from "./ProductGeneratorResult";
-import {ProductState} from "../states/ProductState";
-
-export class IsolatedProductStateGenerator extends ProductSystemGenerator {
-
-  generateIsolatedProductStates() {
-    if(this.productGamesystem.innerGamesystems.length < 2) return;
-
-    const leftInitialData = this.prepareChildsystemForGeneration(this.productGamesystem.innerGamesystems[0])
-    const rightInitialData = this.prepareChildsystemForGeneration(this.productGamesystem.innerGamesystems[1])
-
-    const initialGenerationResult = this.generateBinaryIsolatedProductStates(leftInitialData, rightInitialData);
-
-    if(this.productGamesystem.innerGamesystems.length > 2) {
-      for(let i=2; i<this.productGamesystem.innerGamesystems.length; i++) {
-        const leftData = initialGenerationResult.productGenerationData;
-        const rightData = this.prepareChildsystemForGeneration(this.productGamesystem.innerGamesystems[i]);
-
-        const generationResult = this.generateBinaryIsolatedProductStates(leftData, rightData);
-        this.assignGeneratedStatesAndTransitions(generationResult)
-      }
-    } else {
-      this.assignGeneratedStatesAndTransitions(initialGenerationResult)
-    }
-  }
-
-
-  protected assignGeneratedStatesAndTransitions(generationResult: ProductGeneratorResult) {
-    this.productGamesystem.states = this.productGamesystem.states.concat(generationResult.states);
-    console.log("Generation-Result: ", this.productGamesystem.states)
-  }
-
-  protected generateBinaryIsolatedProductStates(leftSystemData: ProductGenerationData, rightSystemData: ProductGenerationData): ProductGeneratorResult {
-    const generatedProductStates: ProductState[] = []
-    leftSystemData.states.forEach(leftState => {
-      if(leftState.outgoingTransitions.length == 0 && leftState.incomingTransitions.length == 0) {
-        rightSystemData.states.forEach(rightState => {
-          if(rightState.outgoingTransitions.length == 0 && rightState.incomingTransitions.length == 0) {
-            const leftConditions = this.getStateConditions(leftState, true);
-            const rightConditions = this.getStateConditions(rightState, true);
-
-            if(!this.contradictCombinedConditions(leftConditions, rightConditions)) {
-              this.generateBinaryProductState(leftState, rightState, generatedProductStates);
-            }
-          }
-        })
-      }
-    })
-    return new ProductGeneratorResult(generatedProductStates, []);
-  }
-
-}

src/app/project/game-model/gamesystems/productSystemGenerator/IsolatedSymmetricTemplateStateGenerator.ts

@@ -1,48 +0,0 @@
-import {IsolatedTemplateStateGenerator} from "./IsolatedTemplateStateGenerator";
-import {ProductGenerationData} from "./ProductGenerationData";
-import {ProductGeneratorResult} from "./ProductGeneratorResult";
-import {ProductState} from "../states/ProductState";
-import {SimpleState} from "../states/SimpleState";
-import {State} from "../states/State";
-import {ScriptAccountCondition} from "../conditions/ScriptAccountCondition";
-
-export class IsolatedSymmetricTemplateStateGenerator extends IsolatedTemplateStateGenerator{
-
-
-  protected generateBinaryIsolatedProductStates(leftSystemData: ProductGenerationData, rightSystemData: ProductGenerationData): ProductGeneratorResult {
-    console.log("Calling test")
-
-    console.log(leftSystemData.states)
-    console.log(rightSystemData.states)
-
-    const generatedProductStates: ProductState[] = []
-    leftSystemData.states.forEach(leftState => {
-      if(leftState.outgoingTransitions.length == 0 && leftState.incomingTransitions.length == 0) {
-        rightSystemData.states.forEach(rightState => {
-          console.log("LeftState is isolated")
-          if(leftState.equals(rightState)) {
-            if(rightState.outgoingTransitions.length == 0 && rightState.incomingTransitions.length == 0) {
-              const leftConditions = this.getStateConditions(leftState, true);
-              const rightConditions = this.getStateConditions(rightState, true);
-
-              if(!this.contradictCombinedConditions(leftConditions, rightConditions)) {
-                this.generateBinaryProductState(leftState, rightState, generatedProductStates);
-              }
-            }
-          }
-
-          if(leftState.equals(rightState) && rightState.outgoingTransitions.length == 0 && rightState.incomingTransitions.length == 0) {
-            const leftConditions = this.getStateConditions(leftState, true);
-            const rightConditions = this.getStateConditions(rightState, true);
-
-            if(!this.contradictCombinedConditions(leftConditions, rightConditions)) {
-              const generatedState = this.generateBinaryProductState(leftState, rightState, generatedProductStates);
-              console.log(generatedProductStates)
-            }
-          }
-        })
-      }
-    })
-    return new ProductGeneratorResult(generatedProductStates, []);
-  }
-}

src/app/project/game-model/gamesystems/productSystemGenerator/IsolatedTemplateStateGenerator.ts

@@ -1,66 +0,0 @@
-import {IsolatedProductStateGenerator} from "./IsolatedProductStateGenerator";
-import {Transition} from "../transitions/Transition";
-import {SimpleTemplateTransition} from "../../templates/simpleGamesystem/SimpleTemplateTransition";
-import {State} from "../states/State";
-import {ScriptAccountCondition} from "../conditions/ScriptAccountCondition";
-import {SimpleTemplateState} from "../../templates/simpleGamesystem/SimpleTemplateState";
-import {Character} from "../../characters/Character";
-import {CharacterRelation} from "../../characters/CharacterRelation";
-import {TemplateElement} from "../../templates/TemplateElement";
-import {ProductTemplateSystem} from "../../templates/productGamesystem/ProductTemplateSystem";
-import {ProductGeneratorResult} from "./ProductGeneratorResult";
-import {state, transition} from "@angular/animations";
-
-export class IsolatedTemplateStateGenerator extends IsolatedProductStateGenerator {
-  templateElement: TemplateElement
-
-  constructor(productGamesystem: ProductTemplateSystem, templateElement: TemplateElement) {
-    super(productGamesystem);
-    this.templateElement = templateElement;
-  }
-
-
-  protected assignGeneratedStatesAndTransitions(generationResult: ProductGeneratorResult) {
-    const templateSystem = this.productGamesystem as ProductTemplateSystem;
-
-    const nonIsolatedStates = templateSystem.stateMap.get(this.templateElement)!
-    const states = nonIsolatedStates.concat(generationResult.states);
-    templateSystem.stateMap.set(this.templateElement, states)
-  }
-
-  protected getTransitionConditions(transition: Transition<any>, leftSystem: boolean) {
-    const templateElement = this.determineTemplateElement(leftSystem)!;
-    if(transition instanceof SimpleTemplateTransition && transition.conditionMap.has(templateElement)) {
-      return transition.conditionMap.get(templateElement)!
-    }
-    return transition.scriptAccountConditions;
-  }
-
-  protected getTransitionActions(transition: Transition<any>, leftSystem: boolean) {
-    const templateElement = this.determineTemplateElement(leftSystem)!;
-
-    if(transition instanceof SimpleTemplateTransition && transition.actionMap.has(templateElement)) {
-      return transition.actionMap.get(templateElement)!
-    } else {
-      return transition.scriptAccountActions;
-    }
-  }
-
-
-  protected getStateConditions(state: State<any>, leftSystem: boolean): ScriptAccountCondition[] {
-    const templateElement = this.determineTemplateElement(leftSystem)!
-    if(state instanceof  SimpleTemplateState && state.conditionMap.has(templateElement)) {
-      return state.conditionMap.get(templateElement)!
-    } else {
-      return state.conditions
-    }
-  }
-
-  private determineTemplateElement(leftSystem: boolean) {
-    if(this.templateElement instanceof Character) {
-      return this.templateElement;
-    } else if(this.templateElement instanceof CharacterRelation) {
-      return leftSystem ? this.templateElement.firstCharacter : this.templateElement.secondCharacter;
-    }
-  }
-}

src/app/project/game-model/gamesystems/productSystemGenerator/ProductSystemGenerator.ts

@@ -9,7 +9,6 @@ import {Gamesystem} from "../Gamesystem";
 import {ProductGenerationData} from "./ProductGenerationData";
 import {ProductTransition} from "../transitions/ProductTransition";
 import {SimpleTemplateTransition} from "../../templates/simpleGamesystem/SimpleTemplateTransition";
-import {ProductTemplateSystem} from "../../templates/productGamesystem/ProductTemplateSystem";
 
 export class ProductSystemGenerator {
   productGamesystem: ProductGamesystem
@@ -60,12 +59,12 @@ export class ProductSystemGenerator {
             if(startingState != undefined) {
               const endingState_right = this.generateBinaryProductState(leftState, rightState.outgoingTransitions[j].endingState, generatedProductStates);
               if(endingState_right != undefined) {
-                this.generateBinaryProductTransition(startingState, endingState_right, rightState.outgoingTransitions[j], generatedProductTransitions, false);
+                this.generateBinaryProductTransition(startingState, endingState_right, rightState.outgoingTransitions[j], generatedProductTransitions);
               }
 
               const endingState_left = this.generateBinaryProductState(leftState.outgoingTransitions[i].endingState, rightState, generatedProductStates);
               if(endingState_left != undefined) {
-                this.generateBinaryProductTransition(startingState, endingState_left, leftState.outgoingTransitions[i], generatedProductTransitions, true)
+                this.generateBinaryProductTransition(startingState, endingState_left, leftState.outgoingTransitions[i], generatedProductTransitions)
               }
 
               const endingState_left_right = this.generateBinaryProductState(leftState.outgoingTransitions[i].endingState, rightState.outgoingTransitions[j].endingState, generatedProductStates);
@@ -80,7 +79,7 @@ export class ProductSystemGenerator {
             const endingState = this.generateBinaryProductState(leftState.outgoingTransitions[i].endingState, rightState, generatedProductStates);
 
             if(startingState != undefined && endingState != undefined) {
-              this.generateBinaryProductTransition(startingState, endingState, leftState.outgoingTransitions[i], generatedProductTransitions, true)
+              this.generateBinaryProductTransition(startingState, endingState, leftState.outgoingTransitions[i], generatedProductTransitions)
 
             }
           }
@@ -92,7 +91,7 @@ export class ProductSystemGenerator {
             const endingState = this.generateBinaryProductState(leftState, rightState.outgoingTransitions[j].endingState, generatedProductStates);
 
             if(startingState != undefined && endingState != undefined) {
-              this.generateBinaryProductTransition(startingState, endingState, rightState.outgoingTransitions[j], generatedProductTransitions, false);
+              this.generateBinaryProductTransition(startingState, endingState, rightState.outgoingTransitions[j], generatedProductTransitions);
 
             }
 
@@ -107,14 +106,12 @@ export class ProductSystemGenerator {
   protected assignGeneratedStatesAndTransitions(generationResult: ProductGeneratorResult): void {
     this.productGamesystem.states = generationResult.states;
     this.productGamesystem.transitions = generationResult.transitions;
-
-    console.log("General ", generationResult.transitions.length)
   }
 
-  protected generateBinaryProductTransition(startingState: ProductState, endingState: ProductState, usedTransition: Transition<any>, generatedTransitions: ProductTransition[], leftSystem: boolean) {
+  protected generateBinaryProductTransition(startingState: ProductState, endingState: ProductState, usedTransition: Transition<any>, generatedTransitions: ProductTransition[]) {
     const transition = new ProductTransition(startingState, endingState);
-    transition.scriptAccountActions = [... this.getTransitionActions(usedTransition, leftSystem)];
+    transition.scriptAccountActions = [... this.getTransitionActions(usedTransition)];
-    transition.scriptAccountConditions = [... this.getTransitionConditions(usedTransition, leftSystem)];
+    transition.scriptAccountConditions = [... this.getTransitionConditions(usedTransition)];
 
     if(generatedTransitions.find(generatedTransition => generatedTransition.startingState.equals(startingState) && generatedTransition.endingState.equals(endingState)) == undefined) {
       generatedTransitions.push(transition)
@@ -122,13 +119,13 @@ export class ProductSystemGenerator {
   }
 
   protected generateBinaryProductTransitionMulti(startingState: ProductState, endingState: ProductState, leftTransition: Transition<any>, rightTransition: Transition<any>, generatedTransitions: ProductTransition[]) {
-    const leftConditions = this.getTransitionConditions(leftTransition, true)
+    const leftConditions = this.getTransitionConditions(leftTransition)
-    const rightConditions = this.getTransitionConditions(rightTransition, false)
+    const rightConditions = this.getTransitionConditions(rightTransition)
 
     if(!this.contradictCombinedConditions(leftConditions, rightConditions)) {
       const transition = new ProductTransition(startingState, endingState)
-      transition.scriptAccountActions = this.generateCombinedActions(this.getTransitionActions(leftTransition, true), this.getTransitionActions(rightTransition, false));
+      transition.scriptAccountActions = this.generateCombinedActions(this.getTransitionActions(leftTransition), this.getTransitionActions(rightTransition));
-      transition.scriptAccountConditions = this.generateCombinedConditions(this.getTransitionConditions(leftTransition, true), this.getTransitionConditions(rightTransition, false));
+      transition.scriptAccountConditions = this.generateCombinedConditions(this.getTransitionConditions(leftTransition), this.getTransitionConditions(rightTransition));
 
       if(generatedTransitions.find(generatedTransition => generatedTransition.startingState.equals(startingState) && generatedTransition.endingState.equals(endingState)) == undefined) {
         generatedTransitions.push(transition)
@@ -137,8 +134,8 @@ export class ProductSystemGenerator {
   }
 
   protected generateBinaryProductState(leftState: State<any>, rightState: State<any>, generatedStates: ProductState[]): ProductState | undefined {
-    const leftConditions = this.getStateConditions(leftState, true)
+    const leftConditions = this.getStateConditions(leftState)
-    const rightConditions = this.getStateConditions(rightState, false)
+    const rightConditions = this.getStateConditions(rightState)
 
     const combinedStateConditions: ScriptAccountCondition[] = leftConditions.concat(rightConditions)
     for(let i=0; i<combinedStateConditions.length; i++) {
@@ -234,15 +231,15 @@ export class ProductSystemGenerator {
     return false;
   }
 
-  protected getTransitionConditions(transition: Transition<any>, leftSystem: boolean) {
+  protected getTransitionConditions(transition: Transition<any>) {
     return transition.scriptAccountConditions;
   }
 
-  protected getTransitionActions(transition: Transition<any>, leftSystem: boolean) {
+  protected getTransitionActions(transition: Transition<any>) {
     return transition.scriptAccountActions;
   }
 
-  protected getStateConditions(state: State<any>, leftSystem: boolean) {
+  protected getStateConditions(state: State<any>) {
     return state.conditions;
   }
 

src/app/project/game-model/gamesystems/productSystemGenerator/SymmetricProductTemplateGenerator.ts

@@ -1,34 +0,0 @@
-import {TemplateProductSystemGenerator} from "./TemplateProductSystemGenerator";
-import {ProductGenerationData} from "./ProductGenerationData";
-import {ProductGeneratorResult} from "./ProductGeneratorResult";
-import {ProductState} from "../states/ProductState";
-import {ProductTransition} from "../transitions/ProductTransition";
-import {ProductTemplateSystem} from "../../templates/productGamesystem/ProductTemplateSystem";
-
-export class SymmetricProductTemplateGenerator extends TemplateProductSystemGenerator {
-  protected generateFromBinaryChildsystems(leftSystemData: ProductGenerationData, rightSystemData: ProductGenerationData): ProductGeneratorResult {
-    const generatedProductStates: ProductState[] = []
-    const generatedProductTransitions: ProductTransition[] = []
-
-    leftSystemData.states.forEach(leftState => {
-      rightSystemData.states.forEach(rightState => {
-        if(leftState.equals(rightState)) {
-          for(let i=0; i<leftState.outgoingTransitions.length; i++) {
-            for(let j=0; j<rightState.outgoingTransitions.length; j++) {
-              const startingState = this.generateBinaryProductState(leftState, rightState, generatedProductStates);
-              if(startingState != undefined && leftState.outgoingTransitions[i].endingState.equals(rightState.outgoingTransitions[j].endingState)) {
-                const endingState_left_right = this.generateBinaryProductState(leftState.outgoingTransitions[i].endingState, rightState.outgoingTransitions[j].endingState, generatedProductStates);
-                if(endingState_left_right != undefined) {
-                  this.generateBinaryProductTransitionMulti(startingState, endingState_left_right, leftState.outgoingTransitions[i], rightState.outgoingTransitions[j], generatedProductTransitions);
-                }
-              }
-            }
-          }
-        }
-      })
-    })
-
-    return new ProductGeneratorResult(generatedProductStates, generatedProductTransitions);
-  }
-
-}

src/app/project/game-model/gamesystems/productSystemGenerator/TemplateProductSystemGenerator.ts

@@ -10,9 +10,6 @@ import {SimpleTemplateTransition} from "../../templates/simpleGamesystem/SimpleT
 import {state, transition} from "@angular/animations";
 import {ScriptAccountCondition} from "../conditions/ScriptAccountCondition";
 import {SimpleTemplateState} from "../../templates/simpleGamesystem/SimpleTemplateState";
-import {Character} from "../../characters/Character";
-import {CharacterRelation} from "../../characters/CharacterRelation";
-import {ProductGenerationData} from "./ProductGenerationData";
 
 export class TemplateProductSystemGenerator extends ProductSystemGenerator {
 
@@ -28,44 +25,30 @@ export class TemplateProductSystemGenerator extends ProductSystemGenerator {
     const productTemplateSystem = this.productGamesystem as ProductTemplateSystem
     productTemplateSystem.transitionMap.set(this.templateElement, generationResult.transitions)
     productTemplateSystem.stateMap.set(this.templateElement, generationResult.states)
-
-    console.log("Symmetric", (this.productGamesystem as ProductTemplateSystem).symmetric)
-    console.log("Template: ", generationResult.transitions.length)
   }
 
-  protected getTransitionConditions(transition: Transition<any>, leftSystem: boolean) {
+  protected getTransitionConditions(transition: Transition<any>) {
-    const templateElement = this.determineTemplateElement(leftSystem)!;
+    if(transition instanceof SimpleTemplateTransition) {
-    if(transition instanceof SimpleTemplateTransition && transition.conditionMap.has(templateElement)) {
+      return transition.conditionMap.get(this.templateElement)!
-      return transition.conditionMap.get(templateElement)!
+    } else {
-    }
       return transition.scriptAccountConditions;
     }
+  }
 
-  protected getTransitionActions(transition: Transition<any>, leftSystem: boolean) {
+  protected getTransitionActions(transition: Transition<any>) {
-    const templateElement = this.determineTemplateElement(leftSystem)!;
+    if(transition instanceof SimpleTemplateTransition) {
-
+      return transition.actionMap.get(this.templateElement)!
-    if(transition instanceof SimpleTemplateTransition && transition.actionMap.has(templateElement)) {
-      return transition.actionMap.get(templateElement)!
     } else {
       return transition.scriptAccountActions;
     }
   }
 
 
-  protected getStateConditions(state: State<any>, leftSystem: boolean): ScriptAccountCondition[] {
+  protected getStateConditions(state: State<any>): ScriptAccountCondition[] {
-    const templateElement = this.determineTemplateElement(leftSystem)!
+    if(state instanceof  SimpleTemplateState) {
-    if(state instanceof  SimpleTemplateState && state.conditionMap.has(templateElement)) {
+      return state.conditionMap.get(this.templateElement)!
-      return state.conditionMap.get(templateElement)!
     } else {
       return state.conditions
     }
   }
-
-  private determineTemplateElement(leftSystem: boolean) {
-    if(this.templateElement instanceof Character) {
-      return this.templateElement;
-    } else if(this.templateElement instanceof CharacterRelation) {
-      return leftSystem ? this.templateElement.firstCharacter : this.templateElement.secondCharacter;
-    }
-  }
 }

src/app/project/game-model/templates/TemplateType.ts

@@ -1,4 +1,3 @@
 export enum TemplateType {
-  CHARACTER,
+  CHARACTER
-  CHARACTER_RELATION
 }

src/app/project/game-model/templates/TemplateTypeUtilities.ts

@@ -4,8 +4,6 @@ export class TemplateTypeUtilities {
   static fromString(string: string) {
     if(string === 'character') {
       return TemplateType.CHARACTER
-    } else if(string === 'character_relation') {
-      return TemplateType.CHARACTER_RELATION
     }
   }
 }

src/app/project/game-model/templates/productGamesystem/ProductTemplateSystem.ts

@@ -7,20 +7,12 @@ import {SimpleGamesystem} from "../../gamesystems/SimpleGamesystem";
 import {GameModel} from "../../GameModel";
 import {TemplateType} from "../TemplateType";
 import {TemplateProductSystemGenerator} from "../../gamesystems/productSystemGenerator/TemplateProductSystemGenerator";
-import {
-  SymmetricProductTemplateGenerator
-} from "../../gamesystems/productSystemGenerator/SymmetricProductTemplateGenerator";
-import {IsolatedTemplateStateGenerator} from "../../gamesystems/productSystemGenerator/IsolatedTemplateStateGenerator";
-import {
-  IsolatedSymmetricTemplateStateGenerator
-} from "../../gamesystems/productSystemGenerator/IsolatedSymmetricTemplateStateGenerator";
 
 export class ProductTemplateSystem extends ProductGamesystem implements TemplateGamesystem{
 
   stateMap: Map<TemplateElement, ProductState[]> = new Map();
   transitionMap: Map<TemplateElement, ProductTransition[]> = new Map<TemplateElement, ProductTransition[]>()
   templateType: TemplateType
-  symmetric: boolean = false
 
 
   constructor(gamesystemName: string, gamesystemDescription: string, templateType: TemplateType) {
@@ -29,29 +21,8 @@ export class ProductTemplateSystem extends ProductGamesystem implements Template
   }
 
   addTemplateElement(templateElement: TemplateElement): void {
-    if(this.symmetric) {
-      const symmetricGenerator = new SymmetricProductTemplateGenerator(this, templateElement);
-      symmetricGenerator.generateFromChildsystems()
-
-      if(this.generateIsolatedStates) {
-        const isolatedTemplateStateGenerator = new IsolatedSymmetricTemplateStateGenerator(this, templateElement);
-        isolatedTemplateStateGenerator.generateIsolatedProductStates();
-        console.log(this.states)
-        console.log("Generate symmetric isolated states")
-      } else {
-        console.log("Do not generate symmetric isolated states")
-      }
-    } else {
     const productTemplateGenerator = new TemplateProductSystemGenerator(this, templateElement);
     productTemplateGenerator.generateFromChildsystems()
-
-      if(this.generateIsolatedStates) {
-        const isolatedTemplateStateGenerator = new IsolatedTemplateStateGenerator(this, templateElement);
-        isolatedTemplateStateGenerator.generateIsolatedProductStates();
-      }
-    }
-
-
   }
 
 }

src/app/project/game-model/templates/simpleGamesystem/SimpleTemplateGamesystem.ts

@@ -10,7 +10,6 @@ import {TemplateType} from "../TemplateType";
 export class SimpleTemplateGamesystem extends SimpleGamesystem implements TemplateGamesystem {
 
   templateType: TemplateType
-  symmetric: boolean = false
 
   constructor(gamesystemName: string, gamesystemDescription: string, templateType: TemplateType) {
     super(gamesystemName, gamesystemDescription);

src/app/project/parser/characterParser/CharacterParser.ts

@@ -6,21 +6,16 @@ import {ScriptAccountConditionParser} from "../gamesystemParser/ScriptAccountCon
 import {ScriptAccount} from "../../game-model/scriptAccounts/ScriptAccount";
 import {SimpleTemplateState} from "../../game-model/templates/simpleGamesystem/SimpleTemplateState";
 import {SimpleTemplateTransition} from "../../game-model/templates/simpleGamesystem/SimpleTemplateTransition";
-import {CharacterRelation} from "../../game-model/characters/CharacterRelation";
-import {load} from "@angular-devkit/build-angular/src/utils/server-rendering/esm-in-memory-loader/loader-hooks";
-import {Gamesystem} from "../../game-model/gamesystems/Gamesystem";
 
 
 export class CharacterParser {
 
   characterSpecificGamesystems: SimpleTemplateGamesystem[]
-  characterRelationSpecificGamesystems: SimpleTemplateGamesystem[]
   scriptAccountConditionParser: ScriptAccountConditionParser
   scriptAccountActionParser: ScriptAccountActionParser
 
-  constructor(characterSpecificGamesystems: SimpleTemplateGamesystem[], characterRelationSpecificGamesystems: SimpleTemplateGamesystem[], scriptAccounts: ScriptAccount[]) {
+  constructor(characterSpecificGamesystems: SimpleTemplateGamesystem[], scriptAccounts: ScriptAccount[]) {
     this.characterSpecificGamesystems = characterSpecificGamesystems;
-    this.characterRelationSpecificGamesystems = characterRelationSpecificGamesystems;
     this.scriptAccountActionParser = new ScriptAccountActionParser(scriptAccounts);
     this.scriptAccountConditionParser = new ScriptAccountConditionParser(scriptAccounts)
   }
@@ -28,39 +23,29 @@ export class CharacterParser {
 
   public parseCharacters(characters: StoreComponent[]): Character[] {
     const loadedCharacters: Character[] = []
-    characters.forEach(character => loadedCharacters.push(this.parseSingleCharacter(JSON.parse(character.jsonString), loadedCharacters)))
+    characters.forEach(character => loadedCharacters.push(this.parseSingleCharacter(JSON.parse(character.jsonString))))
     return loadedCharacters;
   }
 
-  private parseSingleCharacter(characterData: any, loadedCharacters: Character[]): Character {
+  private parseSingleCharacter(characterData: any): Character {
     const character = new Character(characterData.componentName, characterData.componentDescription);
-
+    const templateSpecificGamesystems = this.parseCharacterSpecificGamesystems(character, characterData.characterSpecificTemplateSystems);
-    loadedCharacters.forEach(loadedCharacter => {
-      const characterRelation = new CharacterRelation(loadedCharacter, character);
-      loadedCharacter.addCharacterRelation(characterRelation)
-      character.addCharacterRelation(characterRelation)
-    })
-
-    const templateSpecificGamesystems = this.parseCharacterSpecificGamesystems(character, characterData.characterSpecificTemplateSystems, this.characterSpecificGamesystems);
     templateSpecificGamesystems.forEach(system => character.addCharacterSpecificSimpleTemplatesystem(system))
-
-    const characterRelationGamesystems = this.parseCharacterSpecificGamesystems(character, characterData.characterRelationGamesystems, this.characterRelationSpecificGamesystems)
-    characterRelationGamesystems.forEach(gamesystem => character.addAsymetricCharacterRelationGamesystem(gamesystem))
     return character;
 
   }
 
-  private parseCharacterSpecificGamesystems(character: Character, characterSpecificGamesystems: any, templateGamesystems: SimpleTemplateGamesystem[]): SimpleTemplateGamesystem[] {
+  private parseCharacterSpecificGamesystems(character: Character, characterSpecificGamesystems: any): SimpleTemplateGamesystem[] {
     const result: SimpleTemplateGamesystem[] = []
     for(let i=0; i<characterSpecificGamesystems.length; i++) {
       const characterSpecificGamesystem = characterSpecificGamesystems[i];
-      result.push(this.parseSingleCharacterSpecificGamesystem(character, characterSpecificGamesystem, templateGamesystems)!)
+      result.push(this.parseSingleCharacterSpecificGamesystem(character, characterSpecificGamesystem)!)
     }
     return result;
   }
 
-  private parseSingleCharacterSpecificGamesystem(character: Character, characterSpecificGamesystem: any, templateGamesystems: SimpleTemplateGamesystem[]): SimpleTemplateGamesystem | undefined{
+  private parseSingleCharacterSpecificGamesystem(character: Character, characterSpecificGamesystem: any): SimpleTemplateGamesystem | undefined{
-    const referencedGamesystem = this.findCharacterSpecificGamesystem(templateGamesystems, characterSpecificGamesystem.componentName)
+    const referencedGamesystem = this.findCharacterSpecificGamesystem(characterSpecificGamesystem.componentName)
 
     if(referencedGamesystem != undefined) {
       for(let i=0; i<characterSpecificGamesystem.states.length; i++) {
@@ -88,8 +73,8 @@ export class CharacterParser {
 
     return referencedGamesystem;
   }
-  private findCharacterSpecificGamesystem(gamesystems: SimpleTemplateGamesystem[], componentName: string): SimpleTemplateGamesystem | undefined{
+  private findCharacterSpecificGamesystem(componentName: string): SimpleTemplateGamesystem | undefined{
-    return gamesystems.find(gamesystem => gamesystem.componentName === componentName)
+    return this.characterSpecificGamesystems.find(gamesystem => gamesystem.componentName === componentName)
   }
 
   private findReferencedState(gamesystem: SimpleTemplateGamesystem, stateLabel: string) {

src/app/project/serializer/CharacterSerializer.ts

@@ -7,7 +7,7 @@ import {Gamesystem} from "../game-model/gamesystems/Gamesystem";
 
 export class CharacterSerializer {
 
-  private static ignoredKeys: string[] = ['unsaved', 'type', 'incomingTransitions', 'outgoingTransitions', 'initial', 'conditions', 'stateDescription', 'templateType', 'parentGamesystem', 'scriptAccountActions', 'scriptAccountConditions', 'characterRelations']
+  private static ignoredKeys: string[] = ['unsaved', 'type', 'incomingTransitions', 'outgoingTransitions', 'initial', 'conditions', 'stateDescription', 'templateType', 'parentGamesystem', 'scriptAccountActions', 'scriptAccountConditions']
 
   public static serializeCharacters(characters: Character[]): StoreComponent[] {
     const storedCharacters: StoreComponent[] = []

testModel/characters/Astrid Hofferson.json

@@ -1,6 +1,50 @@
 {
     "componentName": "Astrid Hofferson",
     "componentDescription": "",
-    "characterSpecificTemplateSystems": [],
+    "characterSpecificTemplateSystems": [
-    "characterRelationGamesystems": []
+        {
+            "componentName": "TemplateGamesystem",
+            "states": [
+                {
+                    "stateLabel": "A",
+                    "conditionMap": [
+                        {
+                            "scriptAccount": "Luftfeuchtigkeit",
+                            "minValue": 0,
+                            "maxValue": "10"
+                        }
+                    ]
+                },
+                {
+                    "stateLabel": "B",
+                    "conditionMap": [
+                        {
+                            "scriptAccount": "New ScriptAccount",
+                            "minValue": 0,
+                            "maxValue": 100
+                        }
+                    ]
+                }
+            ],
+            "transitions": [
+                {
+                    "startingState": "A",
+                    "endingState": "B",
+                    "conditionMap": [
+                        {
+                            "scriptAccount": "Temperature",
+                            "minValue": 0,
+                            "maxValue": 10
+                        }
+                    ],
+                    "actionMap": [
+                        {
+                            "changingValue": 10,
+                            "scriptAccount": "Luftfeuchtigkeit"
+                        }
+                    ]
+                }
+            ]
+        }
+    ]
 }

testModel/characters/Hicks Haddock.json

@@ -1,64 +1,60 @@
 {
     "componentName": "Hicks Haddock",
     "componentDescription": "",
-    "characterSpecificTemplateSystems": [],
+    "characterSpecificTemplateSystems": [
-    "characterRelationGamesystems": [
         {
-            "componentName": "Characterbeziehungssystem",
+            "componentName": "TemplateGamesystem",
             "states": [
                 {
-                    "stateLabel": "Feind",
+                    "stateLabel": "A",
+                    "conditionMap": [
+                        {
+                            "scriptAccount": "Luftfeuchtigkeit",
+                            "minValue": 0,
+                            "maxValue": "10"
+                        }
+                    ]
+                },
+                {
+                    "stateLabel": "B",
+                    "conditionMap": [
+                        {
+                            "scriptAccount": "New ScriptAccount",
+                            "minValue": 0,
+                            "maxValue": 100
+                        }
+                    ]
+                }
+            ],
+            "transitions": [
+                {
+                    "startingState": "A",
+                    "endingState": "B",
+                    "conditionMap": [],
+                    "actionMap": []
+                }
+            ]
+        },
+        {
+            "componentName": "Letters",
+            "states": [
+                {
+                    "stateLabel": "A",
                     "conditionMap": []
                 },
                 {
-                    "stateLabel": "Freund",
+                    "stateLabel": "B",
-                    "conditionMap": []
-                },
-                {
-                    "stateLabel": "Fester Freund",
-                    "conditionMap": []
-                },
-                {
-                    "stateLabel": "Eltern",
-                    "conditionMap": []
-                },
-                {
-                    "stateLabel": "Geschwister",
-                    "conditionMap": []
-                },
-                {
-                    "stateLabel": "Großeltern",
                     "conditionMap": []
                 }
             ],
             "transitions": [
                 {
-                    "startingState": "Feind",
+                    "startingState": "A",
-                    "endingState": "Freund",
+                    "endingState": "B",
-                    "conditionMap": [],
-                    "actionMap": []
-                },
-                {
-                    "startingState": "Freund",
-                    "endingState": "Feind",
-                    "conditionMap": [],
-                    "actionMap": []
-                },
-                {
-                    "startingState": "Freund",
-                    "endingState": "Fester Freund",
-                    "conditionMap": [],
-                    "actionMap": []
-                },
-                {
-                    "startingState": "Fester Freund",
-                    "endingState": "Feind",
                     "conditionMap": [],
                     "actionMap": []
                 }
-            ],
+            ]
-            "generateIsolatedStates": true,
-            "symmetric": true
         }
     ]
 }

testModel/gamesystems/Characterbeziehungssystem.json

@@ -1,71 +0,0 @@
-{
-    "componentName": "Characterbeziehungssystem",
-    "componentDescription": "",
-    "states": [
-        {
-            "initial": false,
-            "conditions": [],
-            "stateLabel": "Feind",
-            "stateDescription": ""
-        },
-        {
-            "initial": true,
-            "conditions": [],
-            "stateLabel": "Freund",
-            "stateDescription": ""
-        },
-        {
-            "initial": false,
-            "conditions": [],
-            "stateLabel": "Fester Freund",
-            "stateDescription": ""
-        },
-        {
-            "initial": false,
-            "conditions": [],
-            "stateLabel": "Eltern",
-            "stateDescription": ""
-        },
-        {
-            "initial": false,
-            "conditions": [],
-            "stateLabel": "Geschwister",
-            "stateDescription": ""
-        },
-        {
-            "initial": false,
-            "conditions": [],
-            "stateLabel": "Großeltern",
-            "stateDescription": ""
-        }
-    ],
-    "transitions": [
-        {
-            "scriptAccountActions": [],
-            "scriptAccountConditions": [],
-            "startingState": "Feind",
-            "endingState": "Freund"
-        },
-        {
-            "scriptAccountActions": [],
-            "scriptAccountConditions": [],
-            "startingState": "Freund",
-            "endingState": "Feind"
-        },
-        {
-            "scriptAccountActions": [],
-            "scriptAccountConditions": [],
-            "startingState": "Freund",
-            "endingState": "Fester Freund"
-        },
-        {
-            "scriptAccountActions": [],
-            "scriptAccountConditions": [],
-            "startingState": "Fester Freund",
-            "endingState": "Feind"
-        }
-    ],
-    "generateIsolatedStates": true,
-    "symmetric": true,
-    "templateType": 1
-}

testModel/gamesystems/NormalGamesystem.json

@@ -0,0 +1,6 @@
+{
+    "componentName": "NormalGamesystem",
+    "componentDescription": "",
+    "states": [],
+    "transitions": []
+}

testModel/gamesystems/Producttest/Letters.json

@@ -0,0 +1,27 @@
+{
+    "componentName": "Letters",
+    "componentDescription": "",
+    "states": [
+        {
+            "initial": false,
+            "conditions": [],
+            "stateLabel": "A",
+            "stateDescription": ""
+        },
+        {
+            "initial": false,
+            "conditions": [],
+            "stateLabel": "B",
+            "stateDescription": ""
+        }
+    ],
+    "transitions": [
+        {
+            "scriptAccountActions": [],
+            "scriptAccountConditions": [],
+            "startingState": "A",
+            "endingState": "B"
+        }
+    ],
+    "templateType": 0
+}

testModel/gamesystems/Producttest/Numbers.json

@@ -0,0 +1,26 @@
+{
+    "componentName": "Numbers",
+    "componentDescription": "",
+    "states": [
+        {
+            "initial": false,
+            "conditions": [],
+            "stateLabel": "1",
+            "stateDescription": ""
+        },
+        {
+            "initial": false,
+            "conditions": [],
+            "stateLabel": "2",
+            "stateDescription": ""
+        }
+    ],
+    "transitions": [
+        {
+            "scriptAccountActions": [],
+            "scriptAccountConditions": [],
+            "startingState": "1",
+            "endingState": "2"
+        }
+    ]
+}

testModel/gamesystems/Producttest/Producttest.json

@@ -0,0 +1,13 @@
+{
+    "componentName": "Producttest",
+    "componentDescription": "",
+    "childsystems": [
+        {
+            "componentName": "Letters"
+        },
+        {
+            "componentName": "Numbers"
+        }
+    ],
+    "templateType": 0
+}

testModel/gamesystems/TemplateGamesystem.json

@@ -0,0 +1,50 @@
+{
+    "componentName": "TemplateGamesystem",
+    "componentDescription": "",
+    "states": [
+        {
+            "initial": false,
+            "conditions": [
+                {
+                    "scriptAccount": "Luftfeuchtigkeit",
+                    "minValue": 0,
+                    "maxValue": "10"
+                }
+            ],
+            "stateLabel": "A",
+            "stateDescription": ""
+        },
+        {
+            "initial": false,
+            "conditions": [
+                {
+                    "scriptAccount": "New ScriptAccount",
+                    "minValue": 0,
+                    "maxValue": 100
+                }
+            ],
+            "stateLabel": "B",
+            "stateDescription": ""
+        }
+    ],
+    "transitions": [
+        {
+            "scriptAccountActions": [
+                {
+                    "changingValue": 10,
+                    "scriptAccount": "Luftfeuchtigkeit"
+                }
+            ],
+            "scriptAccountConditions": [
+                {
+                    "scriptAccount": "Temperature",
+                    "minValue": 0,
+                    "maxValue": 10
+                }
+            ],
+            "startingState": "A",
+            "endingState": "B"
+        }
+    ],
+    "templateType": 0
+}

testModel/gamesystems/Testsystem.json

@@ -0,0 +1,37 @@
+{
+    "componentName": "Testsystem",
+    "componentDescription": "",
+    "states": [
+        {
+            "initial": false,
+            "conditions": [],
+            "stateLabel": "A",
+            "stateDescription": ""
+        },
+        {
+            "initial": false,
+            "conditions": [],
+            "stateLabel": "B",
+            "stateDescription": ""
+        }
+    ],
+    "transitions": [
+        {
+            "scriptAccountActions": [
+                {
+                    "changingValue": 5,
+                    "scriptAccount": "New ScriptAccount"
+                }
+            ],
+            "scriptAccountConditions": [
+                {
+                    "scriptAccount": "Temperature",
+                    "minValue": 0,
+                    "maxValue": "10"
+                }
+            ],
+            "startingState": "A",
+            "endingState": "B"
+        }
+    ]
+}

testModel/gamesystems/Weathersystem/Season.json

@@ -0,0 +1,80 @@
+{
+    "componentName": "Season",
+    "componentDescription": "Ein simples Gamesystem zur Modellierung verschiedener Jahreszeiten und deren Übergänge",
+    "states": [
+        {
+            "initial": true,
+            "conditions": [
+                {
+                    "scriptAccount": "Temperature",
+                    "minValue": 0,
+                    "maxValue": "10"
+                }
+            ],
+            "stateLabel": "Frühling",
+            "stateDescription": ""
+        },
+        {
+            "initial": false,
+            "conditions": [
+                {
+                    "scriptAccount": "Temperature",
+                    "minValue": "10",
+                    "maxValue": "30"
+                }
+            ],
+            "stateLabel": "Sommer",
+            "stateDescription": ""
+        },
+        {
+            "initial": false,
+            "conditions": [
+                {
+                    "scriptAccount": "Temperature",
+                    "minValue": "10",
+                    "maxValue": "20"
+                }
+            ],
+            "stateLabel": "Herbst",
+            "stateDescription": ""
+        },
+        {
+            "initial": false,
+            "conditions": [
+                {
+                    "scriptAccount": "Temperature",
+                    "minValue": "-10",
+                    "maxValue": "10"
+                }
+            ],
+            "stateLabel": "Winter",
+            "stateDescription": ""
+        }
+    ],
+    "transitions": [
+        {
+            "scriptAccountActions": [],
+            "scriptAccountConditions": [],
+            "startingState": "Frühling",
+            "endingState": "Sommer"
+        },
+        {
+            "scriptAccountActions": [],
+            "scriptAccountConditions": [],
+            "startingState": "Sommer",
+            "endingState": "Herbst"
+        },
+        {
+            "scriptAccountActions": [],
+            "scriptAccountConditions": [],
+            "startingState": "Herbst",
+            "endingState": "Winter"
+        },
+        {
+            "scriptAccountActions": [],
+            "scriptAccountConditions": [],
+            "startingState": "Winter",
+            "endingState": "Frühling"
+        }
+    ]
+}

testModel/gamesystems/Weathersystem/Weather.json

@@ -0,0 +1,80 @@
+{
+    "componentName": "Weather",
+    "componentDescription": "A small Gamesystem about local weather events",
+    "states": [
+        {
+            "initial": true,
+            "conditions": [],
+            "stateLabel": "Sonne",
+            "stateDescription": ""
+        },
+        {
+            "initial": false,
+            "conditions": [
+                {
+                    "scriptAccount": "Temperature",
+                    "minValue": 0,
+                    "maxValue": "30"
+                }
+            ],
+            "stateLabel": "Regen",
+            "stateDescription": ""
+        },
+        {
+            "initial": false,
+            "conditions": [],
+            "stateLabel": "Wolke",
+            "stateDescription": ""
+        },
+        {
+            "initial": false,
+            "conditions": [
+                {
+                    "scriptAccount": "Temperature",
+                    "minValue": "-5",
+                    "maxValue": 0
+                }
+            ],
+            "stateLabel": "Schnee",
+            "stateDescription": ""
+        }
+    ],
+    "transitions": [
+        {
+            "scriptAccountActions": [],
+            "scriptAccountConditions": [],
+            "startingState": "Sonne",
+            "endingState": "Wolke"
+        },
+        {
+            "scriptAccountActions": [],
+            "scriptAccountConditions": [],
+            "startingState": "Wolke",
+            "endingState": "Sonne"
+        },
+        {
+            "scriptAccountActions": [],
+            "scriptAccountConditions": [],
+            "startingState": "Wolke",
+            "endingState": "Regen"
+        },
+        {
+            "scriptAccountActions": [],
+            "scriptAccountConditions": [],
+            "startingState": "Regen",
+            "endingState": "Wolke"
+        },
+        {
+            "scriptAccountActions": [],
+            "scriptAccountConditions": [],
+            "startingState": "Wolke",
+            "endingState": "Schnee"
+        },
+        {
+            "scriptAccountActions": [],
+            "scriptAccountConditions": [],
+            "startingState": "Schnee",
+            "endingState": "Wolke"
+        }
+    ]
+}

testModel/gamesystems/Weathersystem/Weathersystem.json

@@ -0,0 +1,12 @@
+{
+    "componentName": "Weathersystem",
+    "componentDescription": "Ein Wettersystem, dass sich aus normalem Wetter (Sonne, Regen, Wolke, Schnee, Sturm etc.) und zusätzlich den Jahreszeiten (Frühling, Sommer, Herbst, Winter, etc.) zusammensetzt.",
+    "childsystems": [
+        {
+            "componentName": "Season"
+        },
+        {
+            "componentName": "Weather"
+        }
+    ]
+}

testModel/script-accounts/Luftfeuchtigkeit.json

@@ -0,0 +1,6 @@
+{
+    "componentName": "Luftfeuchtigkeit",
+    "componentDescription": "",
+    "minValue": 0,
+    "maxValue": 100
+}

testModel/script-accounts/New ScriptAccount.json

@@ -0,0 +1,6 @@
+{
+    "componentName": "New ScriptAccount",
+    "componentDescription": "",
+    "minValue": 0,
+    "maxValue": 100
+}

testModel/script-accounts/Temperature.json

@@ -0,0 +1,6 @@
+{
+    "componentName": "Temperature",
+    "componentDescription": "",
+    "minValue": -30,
+    "maxValue": 50
+}