121 lines
4.6 KiB
TypeScript
121 lines
4.6 KiB
TypeScript
import {Gamesystem} from "./Gamesystem";
|
|
import {ProductState} from "./states/ProductState";
|
|
import {ProductTransition} from "./transitions/ProductTransition";
|
|
import {State} from "./states/State";
|
|
import {Transition} from "./transitions/Transition";
|
|
import {SimpleState} from "./states/SimpleState";
|
|
import {SimpleGamesystem} from "./SimpleGamesystem";
|
|
import {GameModel} from "../GameModel";
|
|
import {ScriptAccountCondition} from "./conditions/ScriptAccountCondition";
|
|
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> {
|
|
|
|
innerGamesystems: Gamesystem<State<any>, Transition<any>>[] = [];
|
|
|
|
static constructFromSimpleGamesystem(simpleGamesystem: SimpleGamesystem, gameModel: GameModel) {
|
|
const productGamesystem = new ProductGamesystem(simpleGamesystem.componentName, simpleGamesystem.componentDescription);
|
|
productGamesystem.constructHierarchyFromSimpleGamesystem(simpleGamesystem, gameModel);
|
|
return productGamesystem;
|
|
}
|
|
|
|
constructHierarchyFromSimpleGamesystem(simpleGamesystem: SimpleGamesystem, gameModel: GameModel) {
|
|
const parentGamesystem = simpleGamesystem.parentGamesystem;
|
|
|
|
if(simpleGamesystem.states.length > 0) {
|
|
simpleGamesystem.componentName += "(Child)";
|
|
this.addChildGamesystem(simpleGamesystem);
|
|
simpleGamesystem.parentGamesystem = this
|
|
}
|
|
|
|
|
|
if(parentGamesystem != undefined) {
|
|
parentGamesystem.removeChildGamesystem(simpleGamesystem);
|
|
parentGamesystem.addChildGamesystem(this);
|
|
this.parentGamesystem = parentGamesystem
|
|
} else {
|
|
gameModel.removeGamesystem(simpleGamesystem);
|
|
gameModel.addGamesystem(this);
|
|
}
|
|
}
|
|
|
|
createState(innerStates: State<any>[]): ProductState | undefined {
|
|
if(innerStates.length == this.innerGamesystems.length && this.findProductStateByInnerStates(innerStates)== undefined) {
|
|
const productState = new ProductState(innerStates);
|
|
this.states.push(productState);
|
|
return productState;
|
|
} else {
|
|
return undefined;
|
|
}
|
|
}
|
|
|
|
createTransition(startingState: ProductState, endingState: ProductState): ProductTransition | undefined {
|
|
if(startingState == undefined || endingState == undefined || this.existsTransition(startingState, endingState)
|
|
|| !this.existsState(startingState) || !this.existsState(endingState) || startingState.equals(endingState)) {
|
|
return undefined;
|
|
}
|
|
|
|
const productTransition = new ProductTransition(startingState, endingState);
|
|
this.transitions.push(productTransition);
|
|
return productTransition;
|
|
}
|
|
|
|
removeState(state: ProductState): boolean {
|
|
return false;
|
|
}
|
|
|
|
removeInnerState(state: SimpleState) {
|
|
|
|
}
|
|
|
|
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>>) {
|
|
this.innerGamesystems.push(gamesystem);
|
|
}
|
|
|
|
removeChildGamesystem(gamesystem: Gamesystem<State<any>, Transition<any>>) {
|
|
this.innerGamesystems = this.innerGamesystems.filter(childSystem => childSystem.componentName !== gamesystem.componentName);
|
|
}
|
|
|
|
findProductStateByInnerStates(innerStates: State<any>[]) {
|
|
return this.states.find(productState => productState.equalInnerStates(innerStates));
|
|
}
|
|
|
|
findChildSystemByName(gamesystemName: string) {
|
|
const gamesystemQueue: Gamesystem<State<any>, Transition<any>>[] = [];
|
|
this.innerGamesystems.forEach(gamesystem => gamesystemQueue.push(gamesystem));
|
|
|
|
while(gamesystemName.length > 0 ){
|
|
const currentGamesystem = gamesystemQueue.shift();
|
|
if(currentGamesystem!.componentName === gamesystemName) {
|
|
return currentGamesystem;
|
|
}
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
private existsTransition(startingState: ProductState, endingState: ProductState) {
|
|
return this.transitions.find(transition =>
|
|
transition.startingState.equals(startingState) && transition.endingState.equals(endingState)) != undefined;
|
|
}
|
|
|
|
private existsState(state: ProductState) {
|
|
return this.states.find(s => s.equals(state)) != undefined;
|
|
}
|
|
|
|
|
|
}
|