306 lines
12 KiB
TypeScript
306 lines
12 KiB
TypeScript
import {Component, NgZone, OnInit, ViewChild} from '@angular/core';
|
|
import {MatDrawerContainer} from "@angular/material/sidenav";
|
|
import {EditorComponent} from "./editor/editor.component";
|
|
import {
|
|
ScriptAccountOverviewComponent
|
|
} from "./side-overviews/script-account-overview/script-account-overview.component";
|
|
import {MatDialog} from "@angular/material/dialog";
|
|
import {DeleteConfirmationDialogComponent} from "./delete-confirmation-dialog/delete-confirmation-dialog.component";
|
|
import {GamescriptOverviewComponent} from "./side-overviews/gamescript-overview/gamescript-overview.component";
|
|
import {ModelComponentType} from "./project/game-model/ModelComponentType";
|
|
import {ModelComponentTypeUtillities} from "./project/game-model/ModelComponentTypeUtillities";
|
|
import {ScriptAccount} from "./project/game-model/scriptAccounts/ScriptAccount";
|
|
import {Gamesystem} from "./project/game-model/gamesystems/Gamesystem";
|
|
import {ModelComponent} from "./project/game-model/ModelComponent";
|
|
import {GameModel} from "./project/game-model/GameModel";
|
|
import {StoredGameModel} from "../../app/storage/StoredGameModel";
|
|
import {GamesystemParser} from "./project/parser/gamesystemParser/GamesystemParser";
|
|
import {ScriptAccountParser} from "./project/parser/ScriptAccountParser";
|
|
import {ElectronService} from "./core/services";
|
|
import {ScriptAccountSerializer} from "./project/serializer/ScriptAccountSerializer";
|
|
import {StoreComponent} from "../../app/storage/StoreComponent";
|
|
import {GamesystemSerializer} from "./project/serializer/GamesystemSerializer";
|
|
import {Character} from "./project/game-model/characters/Character";
|
|
import {CharacterOverviewComponent} from "./side-overviews/character-overview/character-overview.component";
|
|
import {CharacterSerializer} from "./project/serializer/CharacterSerializer";
|
|
import {CharacterParser} from "./project/parser/characterParser/CharacterParser";
|
|
import {TemplateType} from "./project/game-model/templates/TemplateType";
|
|
import {TemplateTypeUtilities} from "./project/game-model/templates/TemplateTypeUtilities";
|
|
import {SimpleTemplateGamesystem} from "./project/game-model/templates/simpleGamesystem/SimpleTemplateGamesystem";
|
|
import {ItemSerializer} from "./project/serializer/ItemSerializer";
|
|
import {ItemgroupParser} from "./project/parser/itemParser/ItemgroupParser";
|
|
|
|
@Component({
|
|
selector: 'app-root',
|
|
templateUrl: './app.component.html',
|
|
styleUrls: ['./app.component.css']
|
|
})
|
|
export class AppComponent implements OnInit{
|
|
|
|
openContent : ModelComponentType | undefined = undefined;
|
|
@ViewChild('drawer') drawer: MatDrawerContainer|undefined
|
|
@ViewChild('editor') editor: EditorComponent|undefined
|
|
@ViewChild('scriptAccountOverview') scriptAccountOverview: ScriptAccountOverviewComponent | undefined
|
|
@ViewChild('gamesystemOverview') gamesystemOverview: GamescriptOverviewComponent | undefined
|
|
@ViewChild('characterOverview') characterOverview: CharacterOverviewComponent | undefined
|
|
|
|
gameModel: GameModel | undefined
|
|
|
|
constructor(private electronService: ElectronService,
|
|
private dialog: MatDialog,
|
|
private zone: NgZone
|
|
) {
|
|
if(electronService.isElectron) {
|
|
electronService.ipcRenderer.on('context-menu', (event: any, message: string) => {
|
|
this.zone.run(() => {
|
|
this.onContextMenuMessageRecieved(message);
|
|
});
|
|
})
|
|
|
|
electronService.ipcRenderer.on('get-project-data', (event: any, message: string) => {
|
|
this.zone.run(() => {
|
|
this.onSaveProject();
|
|
})
|
|
})
|
|
|
|
electronService.ipcRenderer.on('open-project', (event: any, loadedProject: StoredGameModel) => {
|
|
this.zone.run(() => {
|
|
this.onLoadProject(loadedProject)
|
|
})
|
|
})
|
|
|
|
|
|
}
|
|
}
|
|
|
|
onContextMenuMessageRecieved(message: string) {
|
|
if(message == "edit") {
|
|
this.onEditModelComponent();
|
|
} else if(message == "delete") {
|
|
this.onDeleteModelComponent();
|
|
} else if(message.startsWith("new")) {
|
|
const splittedMessage = message.split("-");
|
|
const modelComponentType = ModelComponentTypeUtillities.fromString(splittedMessage[1]);
|
|
const templateType = TemplateTypeUtilities.fromString(splittedMessage[2]);
|
|
if(modelComponentType != undefined) {
|
|
this.onCreateModelComponent(modelComponentType, templateType);
|
|
} else {
|
|
console.log("[ERROR] [App-Component] Unknown Context-Menu Command!")
|
|
}
|
|
}
|
|
}
|
|
|
|
private onEditModelComponent() {
|
|
switch (this.openContent!) {
|
|
case ModelComponentType.SCRIPTACCOUNT: {
|
|
if(this.scriptAccountOverview!.selectedScriptAccount != undefined) {
|
|
this.editor!.openGameModelComponent(this.scriptAccountOverview!.selectedScriptAccount);
|
|
}
|
|
} break;
|
|
case ModelComponentType.GAMESYTEM: {
|
|
if(this.gamesystemOverview!.selectedGamesystem != undefined) {
|
|
const gamesystem = this.gameModel!.findGamesystem(this.gamesystemOverview!.selectedGamesystemName!);
|
|
this.editor!.openGameModelComponent(gamesystem!);
|
|
}
|
|
} break
|
|
case ModelComponentType.CHARACTER: {
|
|
if(this.characterOverview!.selectedCharacter != undefined) {
|
|
this.editor!.openGameModelComponent(this.characterOverview!.selectedCharacter);
|
|
}
|
|
}break
|
|
|
|
}
|
|
}
|
|
|
|
private onDeleteModelComponent() {
|
|
const affectedModelComponent = this.getSelectedModelComponent();
|
|
console.log("Affected ModelComponent: ", affectedModelComponent)
|
|
const dialogRef = this.dialog.open(DeleteConfirmationDialogComponent, {data: affectedModelComponent, minWidth: "400px"});
|
|
|
|
dialogRef.afterClosed().subscribe(res => {
|
|
if(res != undefined && res) {
|
|
if(affectedModelComponent instanceof ScriptAccount) {
|
|
this.gameModel!.removeScriptAccount(affectedModelComponent);
|
|
//this.electronService.ipcRenderer.send('delete-component', new DeleteModel(affectedModelComponent.componentName, ModelComponentType.SCRIPTACCOUNT))
|
|
} else if(affectedModelComponent instanceof Gamesystem) {
|
|
this.gameModel!.removeGamesystem(affectedModelComponent);
|
|
//this.electronService.ipcRenderer.send('delete-component', new DeleteModel(affectedModelComponent.componentName, ModelComponentType.GAMESYTEM))
|
|
this.gamesystemOverview!.refresh()
|
|
} else if(affectedModelComponent instanceof Character) {
|
|
this.gameModel!.removeCharacter(affectedModelComponent)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
|
|
private onCreateModelComponent(modelComponentType: ModelComponentType, templateType: TemplateType | undefined) {
|
|
switch (modelComponentType) {
|
|
case ModelComponentType.SCRIPTACCOUNT: this.onCreateNewScriptAccount(); break
|
|
case ModelComponentType.GAMESYTEM: this.onCreateNewGamesystem(templateType); break
|
|
case ModelComponentType.CHARACTER: this.onCreateNewCharacter(); break
|
|
}
|
|
}
|
|
|
|
private onCreateNewScriptAccount() {
|
|
const createdScriptAccount = this.gameModel!.createScriptAccount("New ScriptAccount");
|
|
if(createdScriptAccount != undefined) {
|
|
this.editor?.openGameModelComponent(createdScriptAccount);
|
|
} else {
|
|
console.log("[DEBUG] [App-Component] ScriptAccount could not be created (Name not unique)");
|
|
}
|
|
}
|
|
|
|
private onCreateNewGamesystem(templateType: TemplateType | undefined) {
|
|
let parentGamesystemName = undefined
|
|
if(this.openContent != ModelComponentType.GAMESYTEM) {
|
|
this.openGamesystemsOverview();
|
|
} else {
|
|
parentGamesystemName = this.gamesystemOverview!.selectedGamesystemName;
|
|
}
|
|
|
|
|
|
let createdGamesystem;
|
|
if(parentGamesystemName == undefined) {
|
|
createdGamesystem = this.gameModel?.createSimpleGamesystem("New Gamesystem", templateType);
|
|
} else {
|
|
createdGamesystem = this.gameModel!.createSimpleGamesystemWithParent("New Gamesystem", parentGamesystemName, templateType)
|
|
}
|
|
|
|
if(createdGamesystem != undefined) {
|
|
this.gamesystemOverview!.refresh();
|
|
this.editor?.openGameModelComponent(createdGamesystem);
|
|
}
|
|
}
|
|
|
|
private onCreateNewCharacter() {
|
|
const createdCharacter = this.gameModel!.createCharacter("New Character")
|
|
if(createdCharacter != undefined) {
|
|
this.editor?.openGameModelComponent(createdCharacter);
|
|
} else {
|
|
console.log("[DEBUG] [App-Component] ScriptAccount could not be created (Name not unique)");
|
|
}
|
|
}
|
|
|
|
private getSelectedModelComponent(): ModelComponent | undefined {
|
|
if(this.openContent == ModelComponentType.SCRIPTACCOUNT) {
|
|
if(this.scriptAccountOverview != undefined) {
|
|
return this.scriptAccountOverview.selectedScriptAccount;
|
|
} else {
|
|
console.log("[WARN] [App.component] ScriptAccountOverview is undefined")
|
|
}
|
|
} else if(this.openContent == ModelComponentType.GAMESYTEM){
|
|
if(this.gamesystemOverview != undefined) {
|
|
return this.gamesystemOverview.getSelectedGamesystem()
|
|
} else {
|
|
console.log("[WARN] [App.component] GamesystemOverview is undefined")
|
|
}
|
|
} else if(this.openContent == ModelComponentType.CHARACTER) {
|
|
if(this.characterOverview != undefined) {
|
|
return this.characterOverview.selectedCharacter;
|
|
} else {
|
|
console.log("[WARN] [App.component] ScriptAccountOverview is undefined")
|
|
}
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
ngOnInit() {
|
|
|
|
}
|
|
|
|
onLoadProject(storedGameModel: StoredGameModel) {
|
|
const gameModel = new GameModel(storedGameModel.gameModelName)
|
|
|
|
const scriptAccounts = ScriptAccountParser.parseScriptAccounts(storedGameModel.storedScriptAccounts);
|
|
|
|
const gamesystemParser = new GamesystemParser(scriptAccounts);
|
|
const gamesystems = gamesystemParser.parseStoredGamesystems(storedGameModel.storedGamesystems);
|
|
|
|
gameModel.scriptAccounts = scriptAccounts
|
|
gameModel.gamesystems = gamesystems
|
|
gameModel.generateProductSystemContents()
|
|
|
|
const characterTemplateSystems = gameModel.getTemplateSystems(TemplateType.CHARACTER).map(templateSystem => templateSystem as SimpleTemplateGamesystem)
|
|
const characterRelationTemplateSystems = gameModel.getTemplateSystems(TemplateType.CHARACTER_RELATION).map(templateSystem => templateSystem as SimpleTemplateGamesystem)
|
|
const characterParser = new CharacterParser(characterTemplateSystems, characterRelationTemplateSystems, gameModel.scriptAccounts);
|
|
gameModel.characters = characterParser.parseCharacters(storedGameModel.storedCharacters)
|
|
|
|
const itemgroupParser = new ItemgroupParser();
|
|
itemgroupParser.parseItemgroups(storedGameModel.storedItemgroups);
|
|
|
|
gameModel.itemgroups = itemgroupParser.getParsedTopItemgroups();
|
|
|
|
this.gameModel = gameModel;
|
|
}
|
|
|
|
onSaveProject() {
|
|
if(this.gameModel != undefined) {
|
|
const storedScriptAccounts = ScriptAccountSerializer.serializeScriptAccounts(this.gameModel.scriptAccounts)
|
|
const storedGamesystems: StoreComponent[] = GamesystemSerializer.serializeGamesystems(this.gameModel.gamesystems)
|
|
const storedCharacters: StoreComponent[] = CharacterSerializer.serializeCharacters(this.gameModel.characters)
|
|
|
|
const itemSerializer = new ItemSerializer();
|
|
const storedItemgroups: StoreComponent[] = itemSerializer.serializeItemgroups(this.gameModel!.itemgroups);
|
|
const storedItems: StoreComponent[] = itemSerializer.getSerializedItems()
|
|
|
|
const storeModel = new StoredGameModel(this.gameModel.gameModelName, storedScriptAccounts, storedGamesystems, storedCharacters, storedItemgroups, storedItems)
|
|
|
|
if(this.electronService.isElectron) {
|
|
this.electronService.ipcRenderer.send('save-model', storeModel)
|
|
}
|
|
}
|
|
}
|
|
|
|
openScriptAccountsOverview() {
|
|
this.openContent = ModelComponentType.SCRIPTACCOUNT
|
|
this.drawer!.open();
|
|
}
|
|
|
|
openGamesystemsOverview() {
|
|
this.openContent = ModelComponentType.GAMESYTEM;
|
|
this.drawer!.open();
|
|
}
|
|
|
|
openCharactersOverview() {
|
|
this.openContent = ModelComponentType.CHARACTER
|
|
this.drawer!.open()
|
|
}
|
|
|
|
openOverview(overviewType: ModelComponentType) {
|
|
this.openContent = overviewType;
|
|
this.drawer!.open();
|
|
}
|
|
|
|
protected readonly ModelComponentType = ModelComponentType;
|
|
|
|
closeContentOverview() {
|
|
this.drawer!.close();
|
|
this.openContent = undefined;
|
|
}
|
|
|
|
protected readonly ModelComponentTypeUtillities = ModelComponentTypeUtillities;
|
|
|
|
openModelComponent(modelComponent: ModelComponent) {
|
|
if(this.editor != undefined) {
|
|
this.editor.openGameModelComponent(modelComponent);
|
|
} else {
|
|
console.log("[WARN] [App.Component] Editor is undefined")
|
|
}
|
|
}
|
|
|
|
onModelNameUpdate() {
|
|
if(this.openContent == ModelComponentType.GAMESYTEM) {
|
|
this.gamesystemOverview!.refresh();
|
|
}
|
|
}
|
|
|
|
resetSelection() {
|
|
if(this.gamesystemOverview != undefined) {
|
|
this.gamesystemOverview.resetSelectedGamesystem()
|
|
}
|
|
}
|
|
|
|
|
|
protected readonly open = open;
|
|
}
|