sebastian/ConceptCreator
1
0
Fork 0
Code Issues 9 Pull Requests Actions Packages Projects Releases Wiki Activity

Fix refactoring and apply refactoring for productsystem generation
Some checks failed
E2E Testing / test (push) Failing after 1m55s
Details

Browse Source
This commit is contained in:
Sebastian Böckelmann 2024-04-12 14:14:11 +02:00
parent 083d993c31
commit fd4dc7b801
2 changed files with 17 additions and 203 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

198
src/app/project/game-model/gamesystems/ProductGamesystem.ts
View File

@ -68,202 +68,8 @@ export class ProductGamesystem extends Gamesystem<ProductState, ProductTransitio
}
generateFromChildsystems() {
//Assume that childsystems that are productsystems are already generated
if(this.innerGamesystems.length < 2) {
//currently only safe-guard
return;
}
const integratedSystems: Gamesystem<any, any>[] = [this.innerGamesystems[0], this.innerGamesystems[1]];
if(this.innerGamesystems[0] instanceof ProductGamesystem) {
this.innerGamesystems[0].generateFromChildsystems();
}
if(this.innerGamesystems[1] instanceof ProductGamesystem) {
this.innerGamesystems[1].generateFromChildsystems();
}
let gamesystem: ProductGamesystem = ProductGamesystem.generateFromChildsystems(this.innerGamesystems[0], this.innerGamesystems[1], false, integratedSystems);
for(let i=2; i<this.innerGamesystems.length; i++) {
if(this.innerGamesystems[i] instanceof ProductGamesystem) {
(this.innerGamesystems[i] as ProductGamesystem).generateFromChildsystems();
}
integratedSystems.push(this.innerGamesystems[i]);
gamesystem = ProductGamesystem.generateFromChildsystems(gamesystem, this.innerGamesystems[i], true, integratedSystems);
}
this.states = gamesystem.states;
this.transitions = gamesystem.transitions;
}
static generateFromChildsystems(leftSystem: Gamesystem<any, any>, rightSystem: Gamesystem<any, any>, left_temp: boolean, integratedSystems: Gamesystem<any, any>[]) {
const productGamesystem = new ProductGamesystem("Temporary Gamesystem", "");
integratedSystems.forEach(integratedSystem => productGamesystem.addChildGamesystem(integratedSystem));
leftSystem.states.forEach(leftState => {
rightSystem.states.forEach(rightState => {
for(let i=0; i<leftState.outgoingTransitions.length; i++) {
for(let j=0; j<rightState.outgoingTransitions.length; j++) {
const startingState = productGamesystem.generateBinaryProductState(leftState, rightState, left_temp);
if(startingState != undefined) {
const endingState_right = productGamesystem.generateBinaryProductState(leftState, rightState.outgoingTransitions[j].endingState, left_temp);
if(endingState_right != undefined) {
const transition_right = productGamesystem.createTransition(startingState, endingState_right);
if(transition_right != undefined) {
transition_right.scriptAccountActions = [...rightState.outgoingTransitions[j].scriptAccountActions]
transition_right.scriptAccountConditions = [... rightState.outgoingTransitions[j].scriptAccountConditions]
}
}
const endingState_left = productGamesystem.generateBinaryProductState(leftState.outgoingTransitions[i].endingState, rightState, left_temp);
if(endingState_left != undefined) {
const transition_left = productGamesystem.createTransition(startingState, endingState_left);
if(transition_left != undefined) {
transition_left.scriptAccountActions = [... leftState.outgoingTransitions[i].scriptAccountActions]
transition_left.scriptAccountConditions = [...leftState.outgoingTransitions[i].scriptAccountConditions]
}
}
const endingState_left_right = productGamesystem.generateBinaryProductState(leftState.outgoingTransitions[i].endingState, rightState.outgoingTransitions[j].endingState, left_temp);
if(endingState_left_right != undefined) {
const leftConditions = leftState.outgoingTransitions[i].scriptAccountConditions;
const rightConditions = rightState.outgoingTransitions[j].scriptAccountConditions;
if(!this.contradictCombinedConditions(leftConditions, rightConditions)) {
const transition_left_right = productGamesystem.createTransition(startingState, endingState_left_right)!;
if(transition_left_right != undefined) {
transition_left_right.scriptAccountActions = this.generateCombinedActions(leftState.outgoingTransitions[i].scriptAccountActions, rightState.outgoingTransitions[j].scriptAccountActions)
transition_left_right.scriptAccountConditions = this.generateCombinedConditions(leftState.outgoingTransitions[i].scriptAccountConditions, rightState.outgoingTransitions[j].scriptAccountConditions)
}
}
}
}
}
if(rightState.outgoingTransitions.length == 0) {
const startingState = productGamesystem.generateBinaryProductState(leftState, rightState, left_temp);
const endingState = productGamesystem.generateBinaryProductState(leftState.outgoingTransitions[i].endingState, rightState, left_temp);
if(startingState != undefined && endingState != undefined) {
const transition = productGamesystem.createTransition(startingState, endingState);
if(transition != undefined) {
transition.scriptAccountActions = [... leftState.outgoingTransitions[i].scriptAccountActions]
transition.scriptAccountConditions = [...leftState.outgoingTransitions[i].scriptAccountConditions]
}
}
}
}
if(leftState.outgoingTransitions.length == 0) {
for(let j=0; j<rightState.outgoingTransitions.length; j++) {
const startingState = productGamesystem.generateBinaryProductState(leftState, rightState, left_temp);
const endingState = productGamesystem.generateBinaryProductState(leftState, rightState.outgoingTransitions[j].endingState, left_temp);
if(startingState != undefined && endingState != undefined) {
const transition = productGamesystem.createTransition(startingState, endingState);
if(transition != undefined) {
transition.scriptAccountActions = [... rightState.outgoingTransitions[j].scriptAccountActions]
transition.scriptAccountConditions = [...rightState.outgoingTransitions[j].scriptAccountConditions]
}
}
}
}
})
})
return productGamesystem;
}
private static generateCombinedActions(leftActions: ScriptAccountAction[], rightActions: 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 static generateCombinedConditions(leftConditions: ScriptAccountCondition[], rightConditions: 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 static 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;
}
generateBinaryProductState(leftInnerState: State<any>, rightInnerState: State<any>, left_temp: boolean) {
const combinedStateConditions: ScriptAccountCondition[] = leftInnerState.conditions.concat(rightInnerState.conditions)
for(let i=0; i<combinedStateConditions.length; i++) {
for(let j=0; j<combinedStateConditions.length; j++) {
if(combinedStateConditions[i].isContradicting(combinedStateConditions[j])) {
return undefined
}
}
}
let innerStates: State<any>[] = [];
if(!left_temp) {
innerStates = [leftInnerState, rightInnerState];
} else {
const left_inner_product_state = leftInnerState as ProductState;
left_inner_product_state.innerStates.forEach(state => innerStates.push(state));
innerStates.push(rightInnerState);
}
let binary_productState = this.findProductStateByInnerStates(innerStates);
if(binary_productState == undefined) {
binary_productState = this.createState(innerStates)!;
}
let productInitial = true;
binary_productState.innerStates.forEach(innerState => productInitial = productInitial && innerState.initial)
binary_productState!.initial = productInitial
binary_productState.conditions = combinedStateConditions
return binary_productState!;
console.log("Debug msg")
this.productGamesystemGenerator.generateFromChildsystems()
}
addChildGamesystem(gamesystem: Gamesystem<State<any>, Transition<any>>) {

10
src/app/project/game-model/gamesystems/productSystemGenerator/ProductGamesystemGenerator.ts
View File

@ -23,7 +23,7 @@ export class ProductGamesystemGenerator {
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]);
@ -32,6 +32,14 @@ export class ProductGamesystemGenerator {
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>) {