Merge pull request 'Introduce Symetric and Asymetric Template Relation Systems' (#40) from assymetric-template-relation-systems into template-systems

Reviewed-on: #40

app/main.ts

@@ -76,6 +76,12 @@ 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,7 +219,8 @@ export class AppComponent implements OnInit{
     gameModel.generateProductSystemContents()
 
     const characterTemplateSystems = gameModel.getTemplateSystems(TemplateType.CHARACTER).map(templateSystem => templateSystem as SimpleTemplateGamesystem)
-    const characterParser = new CharacterParser(characterTemplateSystems, gameModel.scriptAccounts);
+    const characterRelationTemplateSystems = gameModel.getTemplateSystems(TemplateType.CHARACTER_RELATION).map(templateSystem => templateSystem as SimpleTemplateGamesystem)
+    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,3 +14,45 @@
     <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,4 +29,12 @@ 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,3 +1,14 @@
+
 <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,6 +6,8 @@ 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',
@@ -42,4 +44,19 @@ 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,3 +1,4 @@
+
 <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, Output} from '@angular/core';
+import {Component, EventEmitter, Input, OnInit, Output} from '@angular/core';
 import {
   ProductTransitionEditorComponent
 } from "../transition-editor/product-transition-editor/product-transition-editor.component";
@@ -13,12 +13,15 @@ import {TemplateElement} from "../../../project/game-model/templates/TemplateEle
   templateUrl: './product-gamesystem-editor.component.html',
   styleUrl: './product-gamesystem-editor.component.scss'
 })
-export class ProductGamesystemEditorComponent {
+export class ProductGamesystemEditorComponent implements OnInit{
 
   @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 displayedColumns; let i = index" [matColumnDef]="col">
-        <th mat-header-cell *matHeaderCellDef>{{col}}</th>
+      <ng-container *ngFor="let col of internalColumnNames; let i = index" [matColumnDef]="col">
+        <th mat-header-cell *matHeaderCellDef>{{displayedColumns[i]}}</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,6 +29,8 @@ 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>();
 
@@ -38,11 +40,17 @@ 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)!
     }
 
@@ -52,6 +60,20 @@ 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,6 +50,8 @@ 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)
@@ -72,6 +74,20 @@ 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,6 +10,7 @@ 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
@@ -75,6 +76,7 @@ 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) {
@@ -127,12 +129,21 @@ 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,11 +6,16 @@ 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);
   }
@@ -36,8 +41,48 @@ 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

@@ -0,0 +1,38 @@
+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,6 +8,8 @@ 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,6 +11,7 @@ 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> {
 
@@ -74,6 +75,11 @@ 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

@@ -0,0 +1,54 @@
+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

@@ -0,0 +1,48 @@
+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

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

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

@@ -0,0 +1,34 @@
+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,6 +10,9 @@ 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 {
 
@@ -25,30 +28,44 @@ 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>) {
-    if(transition instanceof SimpleTemplateTransition) {
-      return transition.conditionMap.get(this.templateElement)!
-    } else {
+  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>) {
-    if(transition instanceof SimpleTemplateTransition) {
-      return transition.actionMap.get(this.templateElement)!
+  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>): ScriptAccountCondition[] {
-    if(state instanceof  SimpleTemplateState) {
-      return state.conditionMap.get(this.templateElement)!
+  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/templates/TemplateType.ts

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

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

@@ -4,6 +4,8 @@ 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,12 +7,20 @@ 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) {
@@ -21,8 +29,29 @@ 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,6 +10,7 @@ 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,16 +6,21 @@ 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[], scriptAccounts: ScriptAccount[]) {
+  constructor(characterSpecificGamesystems: SimpleTemplateGamesystem[], characterRelationSpecificGamesystems: SimpleTemplateGamesystem[], scriptAccounts: ScriptAccount[]) {
     this.characterSpecificGamesystems = characterSpecificGamesystems;
+    this.characterRelationSpecificGamesystems = characterRelationSpecificGamesystems;
     this.scriptAccountActionParser = new ScriptAccountActionParser(scriptAccounts);
     this.scriptAccountConditionParser = new ScriptAccountConditionParser(scriptAccounts)
   }
@@ -23,29 +28,39 @@ export class CharacterParser {
 
   public parseCharacters(characters: StoreComponent[]): Character[] {
     const loadedCharacters: Character[] = []
-    characters.forEach(character => loadedCharacters.push(this.parseSingleCharacter(JSON.parse(character.jsonString))))
+    characters.forEach(character => loadedCharacters.push(this.parseSingleCharacter(JSON.parse(character.jsonString), loadedCharacters)))
     return loadedCharacters;
   }
 
-  private parseSingleCharacter(characterData: any): Character {
+  private parseSingleCharacter(characterData: any, loadedCharacters: Character[]): 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): SimpleTemplateGamesystem[] {
+  private parseCharacterSpecificGamesystems(character: Character, characterSpecificGamesystems: any, templateGamesystems: SimpleTemplateGamesystem[]): SimpleTemplateGamesystem[] {
     const result: SimpleTemplateGamesystem[] = []
     for(let i=0; i<characterSpecificGamesystems.length; i++) {
       const characterSpecificGamesystem = characterSpecificGamesystems[i];
-      result.push(this.parseSingleCharacterSpecificGamesystem(character, characterSpecificGamesystem)!)
+      result.push(this.parseSingleCharacterSpecificGamesystem(character, characterSpecificGamesystem, templateGamesystems)!)
     }
     return result;
   }
 
-  private parseSingleCharacterSpecificGamesystem(character: Character, characterSpecificGamesystem: any): SimpleTemplateGamesystem | undefined{
-    const referencedGamesystem = this.findCharacterSpecificGamesystem(characterSpecificGamesystem.componentName)
+  private parseSingleCharacterSpecificGamesystem(character: Character, characterSpecificGamesystem: any, templateGamesystems: SimpleTemplateGamesystem[]): SimpleTemplateGamesystem | undefined{
+    const referencedGamesystem = this.findCharacterSpecificGamesystem(templateGamesystems, characterSpecificGamesystem.componentName)
 
     if(referencedGamesystem != undefined) {
       for(let i=0; i<characterSpecificGamesystem.states.length; i++) {
@@ -73,8 +88,8 @@ export class CharacterParser {
 
     return referencedGamesystem;
   }
-  private findCharacterSpecificGamesystem(componentName: string): SimpleTemplateGamesystem | undefined{
-    return this.characterSpecificGamesystems.find(gamesystem => gamesystem.componentName === componentName)
+  private findCharacterSpecificGamesystem(gamesystems: SimpleTemplateGamesystem[], componentName: string): SimpleTemplateGamesystem | undefined{
+    return gamesystems.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']
+  private static ignoredKeys: string[] = ['unsaved', 'type', 'incomingTransitions', 'outgoingTransitions', 'initial', 'conditions', 'stateDescription', 'templateType', 'parentGamesystem', 'scriptAccountActions', 'scriptAccountConditions', 'characterRelations']
 
   public static serializeCharacters(characters: Character[]): StoreComponent[] {
     const storedCharacters: StoreComponent[] = []

testModel/characters/Astrid Hofferson.json

@@ -1,50 +1,6 @@
 {
     "componentName": "Astrid Hofferson",
     "componentDescription": "",
-    "characterSpecificTemplateSystems": [
-        {
-            "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"
-                        }
-                    ]
-                }
-            ]
-        }
-    ]
+    "characterSpecificTemplateSystems": [],
+    "characterRelationGamesystems": []
 }

testModel/characters/Hicks Haddock.json

@@ -1,60 +1,64 @@
 {
     "componentName": "Hicks Haddock",
     "componentDescription": "",
-    "characterSpecificTemplateSystems": [
+    "characterSpecificTemplateSystems": [],
+    "characterRelationGamesystems": [
         {
-            "componentName": "TemplateGamesystem",
+            "componentName": "Characterbeziehungssystem",
             "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": [],
-                    "actionMap": []
-                }
-            ]
-        },
-        {
-            "componentName": "Letters",
-            "states": [
-                {
-                    "stateLabel": "A",
+                    "stateLabel": "Feind",
                     "conditionMap": []
                 },
                 {
-                    "stateLabel": "B",
+                    "stateLabel": "Freund",
+                    "conditionMap": []
+                },
+                {
+                    "stateLabel": "Fester Freund",
+                    "conditionMap": []
+                },
+                {
+                    "stateLabel": "Eltern",
+                    "conditionMap": []
+                },
+                {
+                    "stateLabel": "Geschwister",
+                    "conditionMap": []
+                },
+                {
+                    "stateLabel": "Großeltern",
                     "conditionMap": []
                 }
             ],
             "transitions": [
                 {
-                    "startingState": "A",
-                    "endingState": "B",
+                    "startingState": "Feind",
+                    "endingState": "Freund",
+                    "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

@@ -0,0 +1,71 @@
+{
+    "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

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

testModel/gamesystems/Producttest/Letters.json

@@ -1,27 +0,0 @@
-{
-    "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

@@ -1,26 +0,0 @@
-{
-    "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

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

testModel/gamesystems/TemplateGamesystem.json

@@ -1,50 +0,0 @@
-{
-    "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

@@ -1,37 +0,0 @@
-{
-    "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

@@ -1,80 +0,0 @@
-{
-    "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

@@ -1,80 +0,0 @@
-{
-    "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

@@ -1,12 +0,0 @@
-{
-    "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

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

testModel/script-accounts/New ScriptAccount.json

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

testModel/script-accounts/Temperature.json

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