From 2e66717ae44aaa833dfa8fda18f6a85ffd19eee7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Sebastian=20B=C3=B6ckelmann?= <uqpko@student.kit.edu>
Date: Fri, 12 Apr 2024 14:27:50 +0200
Subject: [PATCH] Refactor ProductGamesystemGenerator to consider other
 alternative implementations of product systems

---
 .../AbstractProductGamesystemGenerator.ts     | 174 +++++++++++++++-
 .../ProductGamesystemGenerator.ts             | 191 ++----------------
 2 files changed, 186 insertions(+), 179 deletions(-)

diff --git a/src/app/project/game-model/gamesystems/productSystemGenerator/AbstractProductGamesystemGenerator.ts b/src/app/project/game-model/gamesystems/productSystemGenerator/AbstractProductGamesystemGenerator.ts
index 495f0f1..fe340a4 100644
--- a/src/app/project/game-model/gamesystems/productSystemGenerator/AbstractProductGamesystemGenerator.ts
+++ b/src/app/project/game-model/gamesystems/productSystemGenerator/AbstractProductGamesystemGenerator.ts
@@ -3,21 +3,181 @@ import {ScriptAccountAction} from "../actions/ScriptAccountAction";
 import {ScriptAccountCondition} from "../conditions/ScriptAccountCondition";
 import {State} from "../states/State";
 import {ProductGamesystem} from "../ProductGamesystem";
+import {ProductGenerationData} from "./ProductGenerationData";
+import {ProductGeneratorResult} from "./ProductGeneratorResult";
+import {ProductState} from "../states/ProductState";
+import {ProductTransition} from "../transitions/ProductTransition";
+import {Transition} from "../transitions/Transition";
 
 export abstract class AbstractProductGamesystemGenerator {
-
-  protected integratedSystems: Gamesystem<any, any>[] = []
+  productGamesystem: ProductGamesystem
 
 
-  prepare() {
-    this.integratedSystems = []
+  constructor(productGamesystem: ProductGamesystem) {
+    this.productGamesystem = productGamesystem;
   }
 
-  abstract generateFromChildsystems(ProductGamesystem: ProductGamesystem): void;
+  generateFromChildsystems(): void {
+    if(this.productGamesystem.innerGamesystems.length < 2) return;
+    const leftInitialData = this.prepareChildsystemForGeneration(this.productGamesystem.innerGamesystems[0])
+    const rightInitialData = this.prepareChildsystemForGeneration(this.productGamesystem.innerGamesystems[1])
 
-  abstract generateFromBinaryChildsystems(leftSystem: Gamesystem<any, any>, rightSystem: any, left_temp: boolean): void;
+    const initialGenerationResult = this.generateFromBinaryChildsystems(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]);
 
-  abstract generateBinaryProductState(leftInnerState: State<any>, rightInnerState: State<any>, left_temp: boolean): State<any>;
+        const generationResult = this.generateFromBinaryChildsystems(leftData, rightData);
+        this.productGamesystem.states = generationResult.states;
+        this.productGamesystem.transitions = generationResult.transitions;
+      }
+    } else {
+      this.productGamesystem.states = initialGenerationResult.states;
+      this.productGamesystem.transitions = initialGenerationResult.transitions
+    }
+  }
 
+  protected prepareChildsystemForGeneration(childsystem: Gamesystem<any, any>) {
+    if(childsystem instanceof ProductGamesystem) {
+      childsystem.productGamesystemGenerator.generateFromChildsystems();
+    }
+
+    return new ProductGenerationData(childsystem.states, childsystem.transitions)
+  }
+
+  protected generateFromBinaryChildsystems(leftSystemData: ProductGenerationData, rightSystemData: ProductGenerationData): ProductGeneratorResult {
+    const generatedProductStates: ProductState[] = []
+    const generatedProductTransitions: ProductTransition[] = []
+
+    leftSystemData.states.forEach(leftState => {
+      rightSystemData.states.forEach(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) {
+              generatedProductStates.push(startingState);
+              const endingState_right = this.generateBinaryProductState(leftState, rightState.outgoingTransitions[j].endingState, generatedProductStates);
+              if(endingState_right != undefined) {
+                const transition_right = this.generateBinaryProductTransition(startingState, endingState_right, rightState.outgoingTransitions[j])
+                generatedProductTransitions.push(transition_right)
+                generatedProductStates.push(endingState_right)
+              }
+
+              const endingState_left = this.generateBinaryProductState(leftState.outgoingTransitions[i].endingState, rightState, generatedProductStates);
+              if(endingState_left != undefined) {
+                const transition = this.generateBinaryProductTransition(startingState, endingState_left, leftState.outgoingTransitions[i])
+                generatedProductTransitions.push(transition)
+                generatedProductStates.push(endingState_left)
+              }
+
+              const endingState_left_right = this.generateBinaryProductState(leftState.outgoingTransitions[i].endingState, rightState.outgoingTransitions[j].endingState, generatedProductStates);
+              if(endingState_left_right != undefined) {
+                const transition = this.generateBinaryProductTransitionMulti(startingState, endingState_left_right, leftState.outgoingTransitions[i], rightState.outgoingTransitions[j]);
+                if(transition != undefined) {
+                  generatedProductStates.push(endingState_left_right);
+                  generatedProductTransitions.push(transition);
+                }
+              }
+            }
+          }
+
+          if(rightState.outgoingTransitions.length == 0) {
+            const startingState = this.generateBinaryProductState(leftState, rightState, generatedProductStates);
+            const endingState = this.generateBinaryProductState(leftState.outgoingTransitions[i].endingState, rightState, generatedProductStates);
+
+            if(startingState != undefined && endingState != undefined) {
+              generatedProductStates.push(startingState)
+              generatedProductStates.push(endingState)
+              const transition = this.generateBinaryProductTransition(startingState, endingState, leftState.outgoingTransitions[i])
+              generatedProductTransitions.push(transition)
+            }
+          }
+        }
+
+        if(leftState.outgoingTransitions.length == 0) {
+          for(let j=0; j<rightState.outgoingTransitions.length; j++) {
+            const startingState = this.generateBinaryProductState(leftState, rightState, generatedProductStates);
+            const endingState = this.generateBinaryProductState(leftState, rightState.outgoingTransitions[j].endingState, generatedProductStates);
+
+            if(startingState != undefined && endingState != undefined) {
+              generatedProductStates.push(startingState)
+              generatedProductStates.push(endingState)
+              const transition = this.generateBinaryProductTransition(startingState, endingState, rightState.outgoingTransitions[j]);
+              generatedProductTransitions.push(transition)
+            }
+
+          }
+        }
+      })
+    })
+
+    return new ProductGeneratorResult(generatedProductStates, generatedProductTransitions);
+  }
+
+  protected abstract generateBinaryProductTransition(leftState: State<any>, rightState: State<any>, usedTransition: Transition<any>): ProductTransition;
+
+  protected abstract generateBinaryProductTransitionMulti(leftState: State<any>, rightState: State<any>, leftTransition: Transition<any>, rightTransition: Transition<any>): ProductTransition | undefined
+
+  protected abstract generateBinaryProductState(leftState: State<any>, rightState: State<any>, generadedStates: ProductState[]): ProductState | undefined
+
+  protected findGeneratedProductState(innerStates: State<any>[], productStates: ProductState[]) {
+    return undefined
+  }
+
+  protected generateCombinedActions(leftActions: ScriptAccountAction[], rightActions: ScriptAccountAction[]): ScriptAccountAction[] {
+    const combinedActions: ScriptAccountAction[] = []
+    for(let i=0; i<leftActions.length; i++) {
+      for(let j=0; j<rightActions.length; j++) {
+        const combinedAction = leftActions[i].combineActions(rightActions[j])
+        if(combinedAction == undefined) {
+          if(!combinedActions.includes(leftActions[i])) {
+            combinedActions.push(leftActions[i])
+          }
+
+          if(!combinedActions.includes(rightActions[j])) {
+            combinedActions.push(rightActions[j])
+          }
+        } else {
+
+          combinedActions.push(combinedAction)
+        }
+      }
+    }
+    return combinedActions;
+  }
+
+  protected generateCombinedConditions(leftConditions: ScriptAccountCondition[], rightConditions: ScriptAccountCondition[]): ScriptAccountCondition[] {
+    const combinedConditions: ScriptAccountCondition[] = [];
+    for(let i=0; i<leftConditions.length; i++) {
+      for(let j=0; j<rightConditions.length; j++) {
+        const combinedCondition = leftConditions[i].combineCondition(rightConditions[j]);
+        if(combinedCondition == undefined) {
+          if(!combinedConditions.includes(leftConditions[i])) {
+            combinedConditions.push(leftConditions[i])
+          }
+
+          if(!combinedConditions.includes(rightConditions[j])) {
+            combinedConditions.push(rightConditions[j])
+          }
+        } else {
+          combinedConditions.push(combinedCondition)
+        }
+      }
+    }
+    return combinedConditions;
+  }
+
+  protected contradictCombinedConditions(leftConditions: ScriptAccountCondition[], rightConditions: ScriptAccountCondition[]): boolean {
+    for(let i=0; i<leftConditions.length; i++) {
+      for(let j=0; j<rightConditions.length; j++) {
+        if(leftConditions[i].isContradicting(rightConditions[j])) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
 
 }
diff --git a/src/app/project/game-model/gamesystems/productSystemGenerator/ProductGamesystemGenerator.ts b/src/app/project/game-model/gamesystems/productSystemGenerator/ProductGamesystemGenerator.ts
index ec4fa25..9823870 100644
--- a/src/app/project/game-model/gamesystems/productSystemGenerator/ProductGamesystemGenerator.ts
+++ b/src/app/project/game-model/gamesystems/productSystemGenerator/ProductGamesystemGenerator.ts
@@ -8,124 +8,12 @@ import {ScriptAccountCondition} from "../conditions/ScriptAccountCondition";
 import {ProductTransition} from "../transitions/ProductTransition";
 import {Transition} from "../transitions/Transition";
 import {ScriptAccountAction} from "../actions/ScriptAccountAction";
+import {AbstractProductGamesystemGenerator} from "./AbstractProductGamesystemGenerator";
 
-export class ProductGamesystemGenerator {
-  productGamesystem: ProductGamesystem
+export class ProductGamesystemGenerator extends AbstractProductGamesystemGenerator{
 
 
-  constructor(productGamesystem: ProductGamesystem) {
-    this.productGamesystem = productGamesystem;
-  }
-
-  generateFromChildsystems(): void {
-    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.generateFromBinaryChildsystems(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.generateFromBinaryChildsystems(leftData, rightData);
-        this.productGamesystem.states = generationResult.states;
-        this.productGamesystem.transitions = generationResult.transitions;
-      }
-    } else {
-      this.productGamesystem.states = initialGenerationResult.states;
-      this.productGamesystem.transitions = initialGenerationResult.transitions
-    }
-
-
-
-
-  }
-
-  private prepareChildsystemForGeneration(childsystem: Gamesystem<any, any>) {
-    if(childsystem instanceof ProductGamesystem) {
-      childsystem.productGamesystemGenerator.generateFromChildsystems();
-    }
-
-    return new ProductGenerationData(childsystem.states, childsystem.transitions)
-  }
-
-  private generateFromBinaryChildsystems(leftSystemData: ProductGenerationData, rightSystemData: ProductGenerationData): ProductGeneratorResult {
-    const generatedProductStates: ProductState[] = []
-    const generatedProductTransitions: ProductTransition[] = []
-
-    leftSystemData.states.forEach(leftState => {
-      rightSystemData.states.forEach(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) {
-              generatedProductStates.push(startingState);
-              const endingState_right = this.generateBinaryProductState(leftState, rightState.outgoingTransitions[j].endingState, generatedProductStates);
-              if(endingState_right != undefined) {
-                const transition_right = this.generateBinaryProductTransition(startingState, endingState_right, rightState.outgoingTransitions[j])
-                generatedProductTransitions.push(transition_right)
-                generatedProductStates.push(endingState_right)
-              }
-
-              const endingState_left = this.generateBinaryProductState(leftState.outgoingTransitions[i].endingState, rightState, generatedProductStates);
-              if(endingState_left != undefined) {
-                const transition = this.generateBinaryProductTransition(startingState, endingState_left, leftState.outgoingTransitions[i])
-                generatedProductTransitions.push(transition)
-                generatedProductStates.push(endingState_left)
-              }
-
-              const endingState_left_right = this.generateBinaryProductState(leftState.outgoingTransitions[i].endingState, rightState.outgoingTransitions[j].endingState, generatedProductStates);
-              if(endingState_left_right != undefined) {
-                const leftConditions = leftState.outgoingTransitions[i].scriptAccountConditions;
-                const rightConditions = rightState.outgoingTransitions[j].scriptAccountConditions;
-                if(!this.contradictCombinedConditions(leftConditions, rightConditions)) {
-                  const transition = new ProductTransition(startingState, endingState_left_right)
-                  transition.scriptAccountActions = this.generateCombinedActions(leftState.outgoingTransitions[i].scriptAccountActions, rightState.outgoingTransitions[j].scriptAccountActions);
-                  transition.scriptAccountConditions = this.generateCombinedConditions(leftState.outgoingTransitions[i].scriptAccountConditions, rightState.outgoingTransitions[j].scriptAccountConditions);
-
-                  generatedProductTransitions.push(transition)
-                  generatedProductStates.push(endingState_left_right)
-                }
-              }
-            }
-          }
-
-          if(rightState.outgoingTransitions.length == 0) {
-            const startingState = this.generateBinaryProductState(leftState, rightState, generatedProductStates);
-            const endingState = this.generateBinaryProductState(leftState.outgoingTransitions[i].endingState, rightState, generatedProductStates);
-
-            if(startingState != undefined && endingState != undefined) {
-              generatedProductStates.push(startingState)
-              generatedProductStates.push(endingState)
-              const transition = this.generateBinaryProductTransition(startingState, endingState, leftState.outgoingTransitions[i])
-              generatedProductTransitions.push(transition)
-            }
-          }
-        }
-
-        if(leftState.outgoingTransitions.length == 0) {
-          for(let j=0; j<rightState.outgoingTransitions.length; j++) {
-            const startingState = this.generateBinaryProductState(leftState, rightState, generatedProductStates);
-            const endingState = this.generateBinaryProductState(leftState, rightState.outgoingTransitions[j].endingState, generatedProductStates);
-
-            if(startingState != undefined && endingState != undefined) {
-              generatedProductStates.push(startingState)
-              generatedProductStates.push(endingState)
-              const transition = this.generateBinaryProductTransition(startingState, endingState, rightState.outgoingTransitions[j]);
-              generatedProductTransitions.push(transition)
-            }
-
-          }
-        }
-      })
-    })
-
-    return new ProductGeneratorResult(generatedProductStates, generatedProductTransitions);
-  }
-
-  private generateBinaryProductTransition(startingState: ProductState, endingState: ProductState, usedTransition: Transition<any>) {
+  protected generateBinaryProductTransition(startingState: ProductState, endingState: ProductState, usedTransition: Transition<any>) {
     const transition = new ProductTransition(startingState, endingState);
     transition.scriptAccountActions = [... usedTransition.scriptAccountActions];
     transition.scriptAccountConditions = [... usedTransition.scriptAccountConditions];
@@ -133,7 +21,22 @@ export class ProductGamesystemGenerator {
     return transition;
   }
 
-  private generateBinaryProductState(leftState: State<any>, rightState: State<any>, generatedStates: ProductState[]): ProductState | undefined {
+  protected generateBinaryProductTransitionMulti(startingState: ProductState, endingState: ProductState, leftTransition: Transition<any>, rightTransition: Transition<any>) {
+    const leftConditions = leftTransition.scriptAccountConditions;
+    const rightConditions = rightTransition.scriptAccountConditions;
+
+    if(!this.contradictCombinedConditions(leftConditions, rightConditions)) {
+      const transition = new ProductTransition(startingState, endingState)
+      transition.scriptAccountActions = this.generateCombinedActions(leftTransition.scriptAccountActions, rightTransition.scriptAccountActions);
+      transition.scriptAccountConditions = this.generateCombinedConditions(leftTransition.scriptAccountConditions, rightTransition.scriptAccountConditions);
+
+      return transition;
+    }
+
+    return undefined;
+  }
+
+  protected generateBinaryProductState(leftState: State<any>, rightState: State<any>, generatedStates: ProductState[]): ProductState | undefined {
     const combinedStateConditions: ScriptAccountCondition[] = leftState.conditions.concat(rightState.conditions);
     for(let i=0; i<combinedStateConditions.length; i++) {
       for(let j=0; j<combinedStateConditions.length; j++) {
@@ -155,63 +58,7 @@ export class ProductGamesystemGenerator {
     return binaryProductState;
   }
 
-  private findGeneratedProductState(innerStates: State<any>[], productStates: ProductState[]) {
-    return undefined
-  }
 
-  private generateCombinedActions(leftActions: ScriptAccountAction[], rightActions: ScriptAccountAction[]): ScriptAccountAction[] {
-    const combinedActions: ScriptAccountAction[] = []
-    for(let i=0; i<leftActions.length; i++) {
-      for(let j=0; j<rightActions.length; j++) {
-        const combinedAction = leftActions[i].combineActions(rightActions[j])
-        if(combinedAction == undefined) {
-          if(!combinedActions.includes(leftActions[i])) {
-            combinedActions.push(leftActions[i])
-          }
-
-          if(!combinedActions.includes(rightActions[j])) {
-            combinedActions.push(rightActions[j])
-          }
-        } else {
-
-          combinedActions.push(combinedAction)
-        }
-      }
-    }
-    return combinedActions;
-  }
-
-  private generateCombinedConditions(leftConditions: ScriptAccountCondition[], rightConditions: ScriptAccountCondition[]): ScriptAccountCondition[] {
-    const combinedConditions: ScriptAccountCondition[] = [];
-    for(let i=0; i<leftConditions.length; i++) {
-      for(let j=0; j<rightConditions.length; j++) {
-        const combinedCondition = leftConditions[i].combineCondition(rightConditions[j]);
-        if(combinedCondition == undefined) {
-          if(!combinedConditions.includes(leftConditions[i])) {
-            combinedConditions.push(leftConditions[i])
-          }
-
-          if(!combinedConditions.includes(rightConditions[j])) {
-            combinedConditions.push(rightConditions[j])
-          }
-        } else {
-          combinedConditions.push(combinedCondition)
-        }
-      }
-    }
-    return combinedConditions;
-  }
-
-  private contradictCombinedConditions(leftConditions: ScriptAccountCondition[], rightConditions: ScriptAccountCondition[]): boolean {
-    for(let i=0; i<leftConditions.length; i++) {
-      for(let j=0; j<rightConditions.length; j++) {
-        if(leftConditions[i].isContradicting(rightConditions[j])) {
-          return true;
-        }
-      }
-    }
-    return false;
-  }