Load CharacterSpecific Gamesystems (at least considered states)

src/app/app.component.ts

@@ -204,7 +204,7 @@ export class AppComponent implements OnInit{
     const gamesystemParser = new GamesystemParser(scriptAccounts);
     const gamesystems = gamesystemParser.parseStoredGamesystems(storedGameModel.storedGamesystems);
 
-    const characterParser = new CharacterParser();
+    const characterParser = new CharacterParser(gamesystemParser.getAllParsedGamesystems(), scriptAccounts);
     const characters = characterParser.parseCharacters(storedGameModel.storedCharacters);
 
     gameModel.scriptAccounts = scriptAccounts

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

@@ -1,9 +1,18 @@
 import {StoreComponent} from "../../../../../app/storage/StoreComponent";
 import {Character} from "../../game-model/characters/Character";
+import {ScriptAccount} from "../../game-model/scriptAccounts/ScriptAccount";
+import {TemplateParser} from "../templateParser/TemplateParser";
+import {Gamesystem} from "../../game-model/gamesystems/Gamesystem";
 
 
 export class CharacterParser {
 
+  private templateParser: TemplateParser
+
+  constructor(gamesystems: Gamesystem<any, any>[],  scriptAccounts: ScriptAccount[]) {
+    this.templateParser = new TemplateParser(gamesystems, scriptAccounts)
+  }
+
   public parseCharacters(characters: StoreComponent[]): Character[] {
     const loadedCharacters: Character[] = []
     characters.forEach(character => loadedCharacters.push(this.parseSingleCharacter(JSON.parse(character.jsonString))))
@@ -11,6 +20,9 @@ export class CharacterParser {
   }
 
   private parseSingleCharacter(characterData: any): Character {
-    return new Character(characterData.componentName, characterData.componentDescription);
+    const character = new Character(characterData.componentName, characterData.componentDescription);
+    character.characterSpecificGamesystems = this.templateParser.parseTemplateGamesystems(characterData.characterSpecificGamesystems)
+    console.log(character.characterSpecificGamesystems)
+    return character;
   }
 }

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

@@ -86,4 +86,7 @@ export class GamesystemParser {
     return undefined
   }
 
+  getAllParsedGamesystems() {
+    return this.parsedGamesystems
+  }
 }

src/app/project/parser/templateParser/TemplateParser.ts

@@ -0,0 +1,45 @@
+import {Gamesystem} from "../../game-model/gamesystems/Gamesystem";
+import {ScriptAccount} from "../../game-model/scriptAccounts/ScriptAccount";
+import {TemplateGamesystem} from "../../game-model/gamesystems/TemplateGamesystem";
+import {StateParser} from "../gamesystemParser/StateParser";
+import {ProductGamesystem} from "../../game-model/gamesystems/ProductGamesystem";
+import {SimpleGamesystem} from "../../game-model/gamesystems/SimpleGamesystem";
+
+export class TemplateParser {
+  private gamesystems: Gamesystem<any, any>[]
+  private stateParser: StateParser
+
+
+  constructor(gamesystems: Gamesystem<any, any>[], scriptAccounts: ScriptAccount[]) {
+    this.gamesystems = gamesystems;
+    this.stateParser = new StateParser(scriptAccounts);
+  }
+
+  parseTemplateGamesystems(templateGamesystemData: any): TemplateGamesystem[] {
+    const templateGamesystems: TemplateGamesystem[] = []
+    for(let i=0; i<templateGamesystemData.length; i++) {
+      const templateSystem = this.parseSingleTemplateGamesystem(templateGamesystemData[i]);
+      if(templateSystem != undefined) {
+        templateGamesystems.push(templateSystem)
+      }
+    }
+    return templateGamesystems;
+  }
+
+  private parseSingleTemplateGamesystem(templateGamesystemData: any) {
+    const referencedGamesystem = this.findReferendGamesystem(templateGamesystemData.referenceGamesystem)
+    if(referencedGamesystem == undefined || referencedGamesystem instanceof ProductGamesystem) {
+      return undefined;
+    }
+
+    const templateStates = this.stateParser.parseStates(templateGamesystemData.templateStates)
+    const templateSystem = new TemplateGamesystem(referencedGamesystem as SimpleGamesystem);
+    templateSystem.templateStates = templateStates
+
+    return templateSystem
+  }
+
+  private findReferendGamesystem(gamesystemName: string) {
+    return this.gamesystems.find(gamesystem => gamesystem.componentName === gamesystemName);
+  }
+}