285 lines
11 KiB
TypeScript
285 lines
11 KiB
TypeScript
import {Gamesystem} from "./gamesystems/Gamesystem";
|
|
import {ScriptAccount} from "./scriptAccounts/ScriptAccount";
|
|
import {Transition} from "./gamesystems/transitions/Transition";
|
|
import {State} from "./gamesystems/states/State";
|
|
import {ProductGamesystem} from "./gamesystems/ProductGamesystem";
|
|
import {SimpleGamesystem} from "./gamesystems/SimpleGamesystem";
|
|
import {Character} from "./characters/Character";
|
|
import {ModelComponentType} from "./ModelComponentType";
|
|
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";
|
|
import {ItemGroup} from "./inventory/ItemGroup";
|
|
import {AbstractItemGroup} from "./inventory/AbstractItemGroup";
|
|
import {ConcreteItemGroup} from "./inventory/ConcreteItemGroup";
|
|
import {Item} from "./inventory/Item";
|
|
import {ItemgroupUtilities} from "./utils/ItemgroupUtilities";
|
|
import {ItemGroupCharacteristic} from "./inventory/ItemgroupCharacteristic";
|
|
|
|
export class GameModel {
|
|
gameModelName: string
|
|
|
|
gamesystems: Gamesystem<any, any>[] = [];
|
|
scriptAccounts: ScriptAccount[] = [];
|
|
characters: Character[] = []
|
|
itemgroups: ItemGroup[] = []
|
|
|
|
constructor(gameModelName: string) {
|
|
this.gameModelName = gameModelName;
|
|
}
|
|
|
|
addAbstractItemgroup(groupName: string, parentgroup: AbstractItemGroup | undefined) {
|
|
//Ensure that Itemgroup does not exist
|
|
if(parentgroup == undefined) {
|
|
if(GameModel.findItemgroupByName(groupName, this.itemgroups) == undefined) {
|
|
const itemgroup = new AbstractItemGroup(groupName, "", ModelComponentType.ITEMGROUP)
|
|
this.itemgroups.push(itemgroup);
|
|
itemgroup.addItemgroupCharacteristic(new ItemGroupCharacteristic("Test0", "", itemgroup));
|
|
}
|
|
} else {
|
|
if(GameModel.findItemgroupByName(groupName, parentgroup.children) == undefined) {
|
|
parentgroup.addChildItemgroup(new AbstractItemGroup(groupName, "", ModelComponentType.ITEMGROUP));
|
|
}
|
|
}
|
|
}
|
|
|
|
addConcreteItemgroup(groupName: string, parentgroup: AbstractItemGroup | undefined) {
|
|
//Ensure that Itemgroup does not exist
|
|
if(parentgroup == undefined) {
|
|
if(GameModel.findItemgroupByName(groupName, this.itemgroups) == undefined) {
|
|
this.itemgroups.push(new ConcreteItemGroup(groupName, "", ModelComponentType.ITEMGROUP));
|
|
}
|
|
} else {
|
|
if(GameModel.findItemgroupByName(groupName, parentgroup.children) == undefined) {
|
|
parentgroup.addChildItemgroup(new ConcreteItemGroup(groupName, "", ModelComponentType.ITEMGROUP));
|
|
}
|
|
}
|
|
}
|
|
|
|
addItem(itemName: string, conceteItemgroupName: string) {
|
|
const itemgroup = GameModel.findItemgroupByName(conceteItemgroupName, this.itemgroups);
|
|
if(itemgroup instanceof ConcreteItemGroup) {
|
|
const itemgroups: ItemGroup[] = ItemgroupUtilities.findItemgroupPathToItemgroup(conceteItemgroupName, this.itemgroups);
|
|
|
|
if(itemgroups.length > 0) {
|
|
const item = new Item(itemName, "", ModelComponentType.ITEM )
|
|
itemgroup.addItem(item, itemgroups)
|
|
return item;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
public static findItemgroupByName(name: string, itemgroups: ItemGroup[]) {
|
|
const itemgroupQueue: ItemGroup[] = itemgroups.concat();
|
|
while(itemgroupQueue.length > 0 ) {
|
|
const currentItemgroup = itemgroupQueue.shift()!;
|
|
|
|
if(currentItemgroup.componentName === name) {
|
|
return currentItemgroup;
|
|
}
|
|
|
|
if(currentItemgroup instanceof AbstractItemGroup) {
|
|
currentItemgroup.children.forEach(itemgroup => itemgroupQueue.push(itemgroup));
|
|
}
|
|
}
|
|
}
|
|
|
|
addGamesystem(gamesystem: Gamesystem<any, any>) {
|
|
if(this.findGamesystem(gamesystem.componentName) == undefined) {
|
|
this.gamesystems.push(gamesystem);
|
|
}
|
|
|
|
}
|
|
|
|
removeGamesystem(gamesystem : Gamesystem<any, any>) {
|
|
if(gamesystem.parentGamesystem == undefined) {
|
|
this.gamesystems = this.gamesystems.filter(g => g !== gamesystem);
|
|
} else {
|
|
(gamesystem.parentGamesystem as ProductGamesystem).removeChildGamesystem(gamesystem);
|
|
}
|
|
}
|
|
|
|
createScriptAccount(scriptAccountName: string) {
|
|
if(scriptAccountName != undefined && scriptAccountName.length > 0) {
|
|
const scriptAccount = new ScriptAccount(scriptAccountName, "");
|
|
const searchedScriptAccount = this.scriptAccounts.find(s => s.componentName === scriptAccount.componentName);
|
|
if(searchedScriptAccount == undefined) {
|
|
this.scriptAccounts.push(scriptAccount);
|
|
return scriptAccount;
|
|
}
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
createSimpleGamesystem(gamesystemName: string, templateType: TemplateType | undefined, pushToTop: boolean = true) {
|
|
if(gamesystemName != undefined && this.findGamesystem(gamesystemName) == undefined) {
|
|
let simpleGamesystem: SimpleGamesystem
|
|
|
|
if(templateType == undefined) {
|
|
simpleGamesystem = new SimpleGamesystem(gamesystemName, "")
|
|
} else {
|
|
simpleGamesystem = new SimpleTemplateGamesystem(gamesystemName, "", templateType)
|
|
}
|
|
|
|
if(pushToTop) {
|
|
this.gamesystems.push(simpleGamesystem)
|
|
}
|
|
return simpleGamesystem;
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
createSimpleGamesystemWithParent(gamesystemName: string, parentGamesystemName: string, templateType: TemplateType | undefined) {
|
|
const simpleGamesystem = this.createSimpleGamesystem(gamesystemName, templateType, false)!;
|
|
|
|
const parentGamesystem = this.findGamesystem(parentGamesystemName)
|
|
if(parentGamesystem == undefined) {return undefined}
|
|
|
|
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) {
|
|
parentProductGamesystem = ProductTemplateCreator.constructTemplateFromSimpleGamesystem(parentGamesystem, this, templateType!)
|
|
} else {
|
|
console.log("Test")
|
|
parentProductGamesystem = ProductGamesystem.constructFromSimpleGamesystem(parentGamesystem, this);
|
|
console.log(this.gamesystems)
|
|
}
|
|
} else {
|
|
if(simpleGamesystem instanceof SimpleTemplateGamesystem) {
|
|
parentProductGamesystem = ProductTemplateCreator.convertProductToTemplate(parentGamesystem as ProductGamesystem, this, templateType!)
|
|
} else {
|
|
parentProductGamesystem = parentGamesystem as ProductGamesystem
|
|
}
|
|
|
|
}
|
|
|
|
parentProductGamesystem.addChildGamesystem(simpleGamesystem);
|
|
simpleGamesystem.parentGamesystem = parentProductGamesystem;
|
|
|
|
return simpleGamesystem;
|
|
}
|
|
|
|
|
|
|
|
createGamesystem(gamesystemName: string, parentGamesystemName: string | undefined, templateType: TemplateType | undefined) {
|
|
if(gamesystemName != undefined && this.findGamesystem(gamesystemName) == undefined) {
|
|
const simpleGamesystem = new SimpleGamesystem(gamesystemName, "");
|
|
|
|
if(parentGamesystemName != undefined) {
|
|
const parentGamesystem = this.findGamesystem(parentGamesystemName);
|
|
if(parentGamesystem instanceof SimpleGamesystem) {
|
|
const parentProductGamesystem = ProductGamesystem.constructFromSimpleGamesystem(parentGamesystem, this);
|
|
parentProductGamesystem.addChildGamesystem(simpleGamesystem);
|
|
simpleGamesystem.parentGamesystem = parentProductGamesystem;
|
|
} else {
|
|
const productParentGamesystem = parentGamesystem as ProductGamesystem;
|
|
productParentGamesystem.addChildGamesystem(simpleGamesystem);
|
|
simpleGamesystem.parentGamesystem = productParentGamesystem;
|
|
}
|
|
} else {
|
|
this.gamesystems.push(simpleGamesystem);
|
|
}
|
|
return simpleGamesystem;
|
|
}
|
|
}
|
|
|
|
createCharacter(characterName: string) {
|
|
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);
|
|
}
|
|
}
|
|
|
|
removeCharacter(character: Character) {
|
|
if(character != undefined) {
|
|
this.characters = this.characters.filter(c => c.componentName !== character.componentName)
|
|
}
|
|
}
|
|
|
|
findGamesystem(gamesystemName: string) {
|
|
const gamesystemQueue : Gamesystem<State<any>, Transition<any>>[] = [];
|
|
this.gamesystems.forEach(gamesystem => gamesystemQueue.push(gamesystem));
|
|
|
|
while(gamesystemQueue.length > 0) {
|
|
const currentGamesystem = gamesystemQueue.shift()!;
|
|
if(currentGamesystem.componentName == gamesystemName) {
|
|
return currentGamesystem;
|
|
} else if(currentGamesystem instanceof ProductGamesystem) {
|
|
const currentProductGamesystem = currentGamesystem as ProductGamesystem;
|
|
currentProductGamesystem.innerGamesystems.forEach(gamesystem => gamesystemQueue.push(gamesystem));
|
|
}
|
|
}
|
|
}
|
|
|
|
addScriptAccount(scriptAccount: ScriptAccount) {
|
|
this.scriptAccounts.push(scriptAccount);
|
|
}
|
|
|
|
generateProductSystemContents() {
|
|
this.gamesystems.forEach(gamesystem => {
|
|
if(gamesystem instanceof ProductGamesystem) {
|
|
gamesystem.generateFromChildsystems();
|
|
}
|
|
})
|
|
}
|
|
|
|
getTemplateSystems(templateType: TemplateType) {
|
|
const requestedTemplates: Gamesystem<any, any>[] = []
|
|
const gamesystemQueue: Gamesystem<any, any>[] = this.gamesystems.concat();
|
|
while(gamesystemQueue.length > 0) {
|
|
const currentGamesystem = gamesystemQueue.shift()!;
|
|
|
|
if(currentGamesystem instanceof SimpleTemplateGamesystem && currentGamesystem.templateType === templateType) {
|
|
requestedTemplates.push(currentGamesystem)
|
|
} else if(currentGamesystem instanceof ProductTemplateSystem && currentGamesystem.templateType === templateType) {
|
|
requestedTemplates.push(currentGamesystem)
|
|
}
|
|
|
|
if(currentGamesystem instanceof ProductGamesystem) {
|
|
currentGamesystem.innerGamesystems.forEach(innerGamesystem => gamesystemQueue.push(innerGamesystem))
|
|
}
|
|
}
|
|
|
|
return requestedTemplates;
|
|
}
|
|
|
|
get itemgroupsAsList() {
|
|
let itemgroupQueue: ItemGroup[] = this.itemgroups.concat();
|
|
const result: ItemGroup[] = []
|
|
while(itemgroupQueue.length > 0) {
|
|
const currentGroup = itemgroupQueue.shift()!;
|
|
|
|
if(currentGroup instanceof AbstractItemGroup) {
|
|
itemgroupQueue = itemgroupQueue.concat(currentGroup.children);
|
|
}
|
|
result.push(currentGroup);
|
|
}
|
|
|
|
return result;
|
|
}
|
|
}
|