diff --git a/makefile b/makefile index 79b0777..e1d0619 100644 --- a/makefile +++ b/makefile @@ -64,14 +64,13 @@ ${dir_erzeugnis}/vtm.js: \ ${dir_quelldatein}/aufbau/stelle.ts \ ${dir_quelldatein}/aufbau/zustand.ts \ ${dir_quelldatein}/aufbau/figur.ts \ - ${dir_quelldatein}/aufbau/aktoren/aktor.ts \ ${dir_quelldatein}/aufbau/aktoren/erzeuger.ts \ ${dir_quelldatein}/aufbau/aktoren/annehmer.ts \ ${dir_quelldatein}/aufbau/aktoren/verwerfer.ts \ ${dir_quelldatein}/aufbau/aktoren/befoerderer.ts \ ${dir_quelldatein}/aufbau/aktoren/schreiber.ts \ ${dir_quelldatein}/aufbau/aktoren/leser.ts \ - ${dir_quelldatein}/aufbau/aktoren/aktor_.ts \ + ${dir_quelldatein}/aufbau/aktoren/aktor.ts \ ${dir_quelldatein}/aufbau/welt.ts \ ${dir_quelldatein}/aufbau/aufgaben/test.ts \ ${dir_quelldatein}/aufbau/aufgaben/akzeptortest.ts \ @@ -108,14 +107,13 @@ ${dir_erzeugnis}/vtm.js: \ ${dir_quelldatein}/aufbau/stelle.ts \ ${dir_quelldatein}/aufbau/zustand.ts \ ${dir_quelldatein}/aufbau/figur.ts \ - ${dir_quelldatein}/aufbau/aktoren/aktor.ts \ ${dir_quelldatein}/aufbau/aktoren/erzeuger.ts \ ${dir_quelldatein}/aufbau/aktoren/annehmer.ts \ ${dir_quelldatein}/aufbau/aktoren/verwerfer.ts \ ${dir_quelldatein}/aufbau/aktoren/befoerderer.ts \ ${dir_quelldatein}/aufbau/aktoren/schreiber.ts \ ${dir_quelldatein}/aufbau/aktoren/leser.ts \ - ${dir_quelldatein}/aufbau/aktoren/aktor_.ts \ + ${dir_quelldatein}/aufbau/aktoren/aktor.ts \ ${dir_quelldatein}/aufbau/welt.ts \ ${dir_quelldatein}/aufbau/aufgaben/test.ts \ ${dir_quelldatein}/aufbau/aufgaben/akzeptortest.ts \ diff --git a/quelldatein/aufbau/aktoren/aktor.ts b/quelldatein/aufbau/aktoren/aktor.ts index 01ed6ce..19d9fc4 100644 --- a/quelldatein/aufbau/aktoren/aktor.ts +++ b/quelldatein/aufbau/aktoren/aktor.ts @@ -18,36 +18,310 @@ module mod_vtm_aufbau { + + /** + * @author kcf + */ + export type typ_aktor = + { + art : string; + angaben ?: any; + } + ; + /** * @author kcf */ - export interface schnittstelle_aktor + export function aktor_erstellen + ( + art : string, + angaben : any = {} + ) + : typ_aktor { - - /** - * @author kcf - */ - drehen(inkrement ?: int) : void; - - - /** - * @author kcf - */ - verwenden(figur : klasse_figur) : void; - - - /** - * @author kcf - */ - exportieren() : any; - - - /** - * @author kcf - */ - // static importieren(roh : any) : schnittstelle_aktor; - + switch (art) + { + case "erzeuger": + { + return { + "art": art, + "angaben": aktor_erzeuger_erstellen(angaben["richtung"]), + }; + break; + } + case "annehmer": + { + return { + "art": art, + "angaben": aktor_annehmer_erstellen(), + }; + break; + } + case "verwerfer": + { + return { + "art": art, + "angaben": aktor_verwerfer_erstellen(), + }; + break; + } + case "befoerderer": + { + return { + "art": art, + "angaben": aktor_befoerderer_erstellen(angaben["richtung"]), + }; + break; + } + case "schreiber": + { + return { + "art": art, + "angaben": aktor_schreiber_erstellen(angaben["richtung"], angaben["symbol"]), + }; + break; + } + case "leser": + { + return { + "art": art, + "angaben": aktor_leser_erstellen(angaben["richtung"], angaben["symbol_links"], angaben["symbol_rechts"]), + }; + break; + } + default: + { + let meldung : string = "unbehandelte Art"; + throw (new Error(meldung)); + break; + } + } + } + + + /** + * @author kcf + */ + export function aktor_drehen + ( + aktor : typ_aktor, + inkrement ?: int + ) + : void + { + switch (aktor.art) + { + case "erzeuger": + { + return aktor_erzeuger_drehen(aktor.angaben, inkrement); + break; + } + case "annehmer": + { + return aktor_annehmer_drehen(aktor.angaben, inkrement); + break; + } + case "verwerfer": + { + return aktor_verwerfer_drehen(aktor.angaben, inkrement); + break; + } + case "befoerderer": + { + return aktor_befoerderer_drehen(aktor.angaben, inkrement); + break; + } + case "schreiber": + { + return aktor_schreiber_drehen(aktor.angaben, inkrement); + break; + } + case "leser": + { + return aktor_leser_drehen(aktor.angaben, inkrement); + break; + } + default: + { + let meldung : string = "unbehandelt"; + throw (new Error(meldung)); + break; + } + } + } + + + /** + * @author kcf + */ + export function aktor_verwenden + ( + aktor : typ_aktor, + figur : typ_figur + ) + : void + { + switch (aktor.art) + { + case "erzeuger": + { + return aktor_erzeuger_verwenden(aktor.angaben, figur); + break; + } + case "annehmer": + { + return aktor_annehmer_verwenden(aktor.angaben, figur); + break; + } + case "verwerfer": + { + return aktor_verwerfer_verwenden(aktor.angaben, figur); + break; + } + case "befoerderer": + { + return aktor_befoerderer_verwenden(aktor.angaben, figur); + break; + } + case "schreiber": + { + return aktor_schreiber_verwenden(aktor.angaben, figur); + break; + } + case "leser": + { + return aktor_leser_verwenden(aktor.angaben, figur); + break; + } + default: + { + let meldung : string = "unbehandelt"; + throw (new Error(meldung)); + break; + } + } + } + + + + /** + * @author kcf + */ + export function aktor_exportieren + ( + aktor : typ_aktor + ) + : any + { + switch (aktor.art) + { + case "erzeuger": + { + return aktor_erzeuger_exportieren(aktor.angaben); + break; + } + case "annehmer": + { + return aktor_annehmer_exportieren(aktor.angaben); + break; + } + case "verwerfer": + { + return aktor_verwerfer_exportieren(aktor.angaben); + break; + } + case "befoerderer": + { + return aktor_befoerderer_exportieren(aktor.angaben); + break; + } + case "schreiber": + { + return aktor_schreiber_exportieren(aktor.angaben); + break; + } + case "leser": + { + return aktor_leser_exportieren(aktor.angaben); + break; + } + default: + { + let meldung : string = "unbehandelt"; + throw (new Error(meldung)); + break; + } + } + } + + + /** + * @author kcf + */ + export function aktor_importieren + ( + roh : any + ) + : typ_aktor + { + switch (roh["art"]) + { + case "erzeuger": + { + return { + "art": roh["art"], + "angaben": aktor_erzeuger_importieren(roh["angaben"]), + }; + break; + } + case "annehmer": + { + return { + "art": roh["art"], + "angaben": aktor_annehmer_importieren(roh["angaben"]), + }; + break; + } + case "verwerfer": + { + return { + "art": roh["art"], + "angaben": aktor_verwerfer_importieren(roh["angaben"]), + }; + break; + } + case "befoerderer": + { + return { + "art": roh["art"], + "angaben": aktor_befoerderer_importieren(roh["angaben"]), + }; + break; + } + case "schreiber": + { + return { + "art": roh["art"], + "angaben": aktor_schreiber_importieren(roh["angaben"]), + }; + break; + } + case "leser": + { + return { + "art": roh["art"], + "angaben": aktor_leser_importieren(roh["angaben"]), + }; + break; + } + default: + { + let meldung : string = "unbehandelte Art"; + throw (new Error(meldung)); + break; + } + } } } diff --git a/quelldatein/aufbau/aktoren/aktor_.ts b/quelldatein/aufbau/aktoren/aktor_.ts deleted file mode 100644 index d65eeaf..0000000 --- a/quelldatein/aufbau/aktoren/aktor_.ts +++ /dev/null @@ -1,124 +0,0 @@ -/* - * Verrückte Turing-Maschinen — A turing complete game - * Copyright (C) 2016 Christian Fraß - * - * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - */ - -module mod_vtm_aufbau - { - - /** - * @author kcf - */ - export function aktor_exportieren(aktor : schnittstelle_aktor) : any - { - if (aktor instanceof klasse_erzeuger) - { - return { - "art": "erzeuger", - "angaben": aktor.exportieren() - }; - } - else if (aktor instanceof klasse_annehmer) - { - return { - "art": "annehmer", - "angaben": aktor.exportieren() - }; - } - else if (aktor instanceof klasse_verwerfer) - { - return { - "art": "verwerfer", - "angaben": aktor.exportieren() - }; - } - else if (aktor instanceof klasse_befoerderer) - { - return { - "art": "befoerderer", - "angaben": aktor.exportieren() - }; - } - else if (aktor instanceof klasse_schreiber) - { - return { - "art": "schreiber", - "angaben": aktor.exportieren() - }; - } - else if (aktor instanceof klasse_leser) - { - return { - "art": "leser", - "angaben": aktor.exportieren() - }; - } - else - { - let meldung : string = "unbehandelte Klasse"; - throw (new Error(meldung)); - } - } - - - /** - * @author kcf - */ - export function aktor_importieren(aktor_roh : any) : schnittstelle_aktor - { - switch (aktor_roh["art"]) - { - case "erzeuger": - { - return klasse_erzeuger.importieren(aktor_roh["angaben"]); - break; - } - case "annehmer": - { - return klasse_annehmer.importieren(aktor_roh["angaben"]); - break; - } - case "verwerfer": - { - return klasse_verwerfer.importieren(aktor_roh["angaben"]); - break; - } - case "befoerderer": - { - return klasse_befoerderer.importieren(aktor_roh["angaben"]); - break; - } - case "schreiber": - { - return klasse_schreiber.importieren(aktor_roh["angaben"]); - break; - } - case "leser": - { - return klasse_leser.importieren(aktor_roh["angaben"]); - break; - } - default: - { - let meldung : string = "unbehandelte Art"; - throw (new Error(meldung)); - break; - } - } - } - - } - diff --git a/quelldatein/aufbau/aktoren/annehmer.ts b/quelldatein/aufbau/aktoren/annehmer.ts index f331463..241b47e 100644 --- a/quelldatein/aufbau/aktoren/annehmer.ts +++ b/quelldatein/aufbau/aktoren/annehmer.ts @@ -3,16 +3,16 @@ * Copyright (C) 2016 Christian Fraß * * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by + * it under the terms of the GNU General export function aktor_annehmer_License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * GNU General export function aktor_annehmer_License for more details. * - * You should have received a copy of the GNU General Public License + * You should have received a copy of the GNU General export function aktor_annehmer_License * along with this program. If not, see . */ @@ -22,61 +22,62 @@ module mod_vtm_aufbau /** * @author kcf */ - export class klasse_annehmer - implements schnittstelle_aktor + export type typ_aktor_annehmer = { - - /** - * @author kcf - */ - public constructor() - { - } - - - /** - * @author kcf - * @implementation - */ - public drehen(inkrement ?: int) : void - { - } - - - /** - * @author kcf - * @implementation - */ - public verwenden(figur : klasse_figur) : void - { - figur.annehmen(); - } - - - /** - * @author kcf - * @implementation - */ - public exportieren() : any - { - return { - }; - } - - - /** - * @author kcf - * @implementation - */ - public static importieren(roh : any) : klasse_annehmer - { - return ( - new klasse_annehmer - ( - ) - ); - } - + } + ; + + + /** + * @author kcf + */ + export function aktor_annehmer_erstellen + ( + ) + : typ_aktor_annehmer + { + return { + }; + } + + + /** + * @author kcf + */ + export function aktor_annehmer_drehen(aktor_annehmer : typ_aktor_annehmer, inkrement ?: int) : void + { + } + + + /** + * @author kcf + */ + export function aktor_annehmer_verwenden(aktor_annehmer : typ_aktor_annehmer, figur : typ_figur) : void + { + figur_annehmen(figur); + } + + + /** + * @author kcf + */ + export function aktor_annehmer_exportieren(aktor_annehmer : typ_aktor_annehmer) : any + { + return { + }; + } + + + /** + * @author kcf + */ + export function aktor_annehmer_importieren(roh : any) : typ_aktor_annehmer + { + return ( + aktor_annehmer_erstellen + ( + ) + ); } } diff --git a/quelldatein/aufbau/aktoren/befoerderer.ts b/quelldatein/aufbau/aktoren/befoerderer.ts index 345ca96..6792f2a 100644 --- a/quelldatein/aufbau/aktoren/befoerderer.ts +++ b/quelldatein/aufbau/aktoren/befoerderer.ts @@ -3,16 +3,16 @@ * Copyright (C) 2016 Christian Fraß * * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by + * it under the terms of the GNU General export function aktor_befoerderer_License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * GNU General export function aktor_befoerderer_License for more details. * - * You should have received a copy of the GNU General Public License + * You should have received a copy of the GNU General export function aktor_befoerderer_License * along with this program. If not, see . */ @@ -22,80 +22,73 @@ module mod_vtm_aufbau /** * @author kcf */ - export class klasse_befoerderer - implements schnittstelle_aktor + export type typ_aktor_befoerderer = { - - /** - * @author kcf - */ - private richtung : typ_richtung; - - - /** - * @author kcf - */ - public constructor(richtung : typ_richtung = 0) - { - this.richtung = richtung; - } - - - /** - * @author kcf - */ - public richtung_lesen() : typ_richtung - { - return this.richtung; - } - - - /** - * @author kcf - * @implementation - */ - public drehen(inkrement : int = +1) : void - { - this.richtung = richtung_addieren(this.richtung, inkrement); - } - - - /** - * @author kcf - * @implementation - */ - public verwenden(figur : klasse_figur) : void - { - figur.bewegen(this.richtung); - } - - - /** - * @author kcf - * @implementation - */ - public exportieren() : any - { - return { - "richtung": richtung_exportieren(this.richtung), - }; - } - - - /** - * @author kcf - * @implementation - */ - public static importieren(roh : any) : klasse_befoerderer - { - return ( - new klasse_befoerderer - ( - richtung_importieren(roh["richtung"]) - ) - ); - } - + richtung : typ_richtung; + } + ; + + + /** + * @author kcf + */ + export function aktor_befoerderer_erstellen(richtung : typ_richtung = 0) : typ_aktor_befoerderer + { + return { + "richtung": richtung, + }; + } + + + /** + * @author kcf + */ + export function aktor_befoerderer_richtung_lesen(aktor_befoerderer : typ_aktor_befoerderer) : typ_richtung + { + return aktor_befoerderer.richtung; + } + + + /** + * @author kcf + */ + export function aktor_befoerderer_drehen(aktor_befoerderer : typ_aktor_befoerderer, inkrement : int = +1) : void + { + aktor_befoerderer.richtung = richtung_addieren(aktor_befoerderer.richtung, inkrement); + } + + + /** + * @author kcf + */ + export function aktor_befoerderer_verwenden(aktor_befoerderer : typ_aktor_befoerderer, figur : typ_figur) : void + { + figur_bewegen(figur, aktor_befoerderer.richtung); + } + + + /** + * @author kcf + */ + export function aktor_befoerderer_exportieren(aktor_befoerderer : typ_aktor_befoerderer) : any + { + return { + "richtung": richtung_exportieren(aktor_befoerderer.richtung), + }; + } + + + /** + * @author kcf + */ + export function aktor_befoerderer_importieren(roh : any) : typ_aktor_befoerderer + { + return ( + aktor_befoerderer_erstellen + ( + richtung_importieren(roh["richtung"]) + ) + ); } } diff --git a/quelldatein/aufbau/aktoren/erzeuger.ts b/quelldatein/aufbau/aktoren/erzeuger.ts index ac9332e..706c7d0 100644 --- a/quelldatein/aufbau/aktoren/erzeuger.ts +++ b/quelldatein/aufbau/aktoren/erzeuger.ts @@ -22,80 +22,99 @@ module mod_vtm_aufbau /** * @author kcf */ - export class klasse_erzeuger - implements schnittstelle_aktor + export type typ_aktor_erzeuger = { - - /** - * @author kcf - */ - private richtung : typ_richtung; - - - /** - * @author kcf - */ - public constructor(richtung : typ_richtung = 0) - { - this.richtung = richtung; - } - - - /** - * @author kcf - */ - public richtung_lesen() : typ_richtung - { - return this.richtung; - } - - - /** - * @author kcf - * @implementation - */ - public drehen(inkrement : int = +1) : void - { - this.richtung = richtung_addieren(this.richtung, inkrement); - } - - - /** - * @author kcf - * @implementation - */ - public verwenden(figur : klasse_figur) : void - { - figur.bewegen(this.richtung); - } - - - /** - * @author kcf - * @implementation - */ - public exportieren() : any - { - return { - "richtung": richtung_exportieren(this.richtung), - }; - } - - - /** - * @author kcf - * @implementation - */ - public static importieren(roh : any) : klasse_erzeuger - { - return ( - new klasse_erzeuger - ( - richtung_importieren(roh["richtung"]) - ) - ); - } - + richtung : typ_richtung; + } + ; + + + /** + * @author kcf + */ + export function aktor_erzeuger_erstellen + ( + richtung : typ_richtung = 0 + ) + : typ_aktor_erzeuger + { + return { + "richtung": richtung, + }; + } + + + /** + * @author kcf + */ + export function aktor_erzeuger_richtung_lesen + ( + aktor_erzeuger : typ_aktor_erzeuger + ) + : typ_richtung + { + return aktor_erzeuger.richtung; + } + + + /** + * @author kcf + */ + export function aktor_erzeuger_drehen + ( + aktor_erzeuger : typ_aktor_erzeuger, + inkrement : int = +1 + ) + : void + { + aktor_erzeuger.richtung = richtung_addieren(aktor_erzeuger.richtung, inkrement); + } + + + /** + * @author kcf + */ + export function aktor_erzeuger_verwenden + ( + aktor_erzeuger : typ_aktor_erzeuger, + figur : typ_figur + ) + : void + { + figur_bewegen(figur, aktor_erzeuger.richtung); + } + + + /** + * @author kcf + */ + export function aktor_erzeuger_exportieren + ( + aktor_erzeuger : typ_aktor_erzeuger + ) + : any + { + return { + "richtung": richtung_exportieren(aktor_erzeuger.richtung), + }; + } + + + /** + * @author kcf + */ + export function aktor_erzeuger_importieren + ( + roh : any + ) + : typ_aktor_erzeuger + { + return ( + aktor_erzeuger_erstellen + ( + richtung_importieren(roh["richtung"]) + ) + ); } } diff --git a/quelldatein/aufbau/aktoren/leser.ts b/quelldatein/aufbau/aktoren/leser.ts index c348820..5e5a7ce 100644 --- a/quelldatein/aufbau/aktoren/leser.ts +++ b/quelldatein/aufbau/aktoren/leser.ts @@ -3,16 +3,16 @@ * Copyright (C) 2016 Christian Fraß * * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by + * it under the terms of the GNU General export function aktor_leser_License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * GNU General export function aktor_leser_License for more details. * - * You should have received a copy of the GNU General Public License + * You should have received a copy of the GNU General export function aktor_leser_License * along with this program. If not, see . */ @@ -22,141 +22,124 @@ module mod_vtm_aufbau /** * @author kcf */ - export class klasse_leser - implements schnittstelle_aktor + export type typ_aktor_leser = { - - /** - * @author kcf - */ - private richtung : typ_richtung; - - - /** - * @author kcf - */ - private symbol_links : typ_symbol; - - - /** - * @author kcf - */ - private symbol_rechts : typ_symbol; - - - /** - * @author kcf - */ - public constructor(richtung : typ_richtung = 0, symbol_links : typ_symbol = 0, symbol_rechts : typ_symbol = 1) + "richtung": typ_richtung, + "symbol_links": typ_symbol, + "symbol_rechts": typ_symbol, + } + ; + + + /** + * @author kcf + */ + export function aktor_leser_erstellen(richtung : typ_richtung = 0, symbol_links : typ_symbol = 0, symbol_rechts : typ_symbol = 1) : typ_aktor_leser + { + return { + "richtung": richtung, + "symbol_links": symbol_links, + "symbol_rechts": symbol_rechts, + }; + } + + + /** + * @author kcf + */ + export function aktor_leser_richtung_lesen(aktor_leser : typ_aktor_leser) : typ_richtung + { + return aktor_leser.richtung; + } + + + /** + * @author kcf + */ + export function aktor_leser_symbol_links_lesen(aktor_leser : typ_aktor_leser) : typ_symbol + { + return aktor_leser.symbol_links; + } + + + /** + * @author kcf + */ + export function aktor_leser_symbol_rechts_lesen(aktor_leser : typ_aktor_leser) : typ_symbol + { + return aktor_leser.symbol_rechts; + } + + + /** + * @author kcf + */ + export function aktor_leser_drehen(aktor_leser : typ_aktor_leser, inkrement : int = +1) : void + { + aktor_leser.richtung = richtung_addieren(aktor_leser.richtung, inkrement); + } + + + /** + * @author kcf + */ + export function aktor_leser_verwenden(aktor_leser : typ_aktor_leser, figur : typ_figur) : void + { + let symbol_ : schnittstelle_fehlermonade = figur_lesen(figur); + let summand : typ_richtung; + if (symbol_.ist_schlicht()) { - this.richtung = richtung; - this.symbol_links = symbol_links; - this.symbol_rechts = symbol_rechts; - } - - - /** - * @author kcf - */ - public richtung_lesen() : typ_richtung - { - return this.richtung; - } - - - /** - * @author kcf - */ - public symbol_links_lesen() : typ_symbol - { - return this.symbol_links; - } - - - /** - * @author kcf - */ - public symbol_rechts_lesen() : typ_symbol - { - return this.symbol_rechts; - } - - - /** - * @author kcf - * @implementation - */ - public drehen(inkrement : int = +1) : void - { - this.richtung = richtung_addieren(this.richtung, inkrement); - } - - - /** - * @author kcf - * @implementation - */ - public verwenden(figur : klasse_figur) : void - { - let symbol_ : schnittstelle_fehlermonade = figur.lesen(); - let summand : typ_richtung; - if (symbol_.ist_schlicht()) + let symbol : typ_symbol = symbol_.lesen(); + if (symbol === aktor_leser.symbol_links) { - let symbol : typ_symbol = symbol_.lesen(); - if (symbol === this.symbol_links) - { - figur.schieben(); - summand = +2; - } - else if (symbol === this.symbol_rechts) - { - figur.schieben(); - summand = -2; - } - else - { - summand = 0; - } + figur_schieben(figur); + summand = +2; + } + else if (symbol === aktor_leser.symbol_rechts) + { + figur_schieben(figur); + summand = -2; } else { summand = 0; } - let richtung : typ_richtung = richtung_addieren(this.richtung, summand); - figur.bewegen(richtung); } - - - /** - * @author kcf - * @implementation - */ - public exportieren() : any + else { - return { - "richtung": richtung_exportieren(this.richtung), - "symbol_links": symbol_exportieren(this.symbol_links), - "symbol_rechts": symbol_exportieren(this.symbol_rechts), - }; + summand = 0; } - - - /** - * @author kcf - * @implementation - */ - public static importieren(roh : any) : klasse_leser - { - return ( - new klasse_leser - ( - richtung_importieren(roh["richtung"]), - symbol_importieren(roh["symbol_links"]), - symbol_importieren(roh["symbol_rechts"]) - ) - ); - } - + let richtung : typ_richtung = richtung_addieren(aktor_leser.richtung, summand); + figur_bewegen(figur, richtung); + } + + + /** + * @author kcf + */ + export function aktor_leser_exportieren(aktor_leser : typ_aktor_leser) : any + { + return { + "richtung": richtung_exportieren(aktor_leser.richtung), + "symbol_links": symbol_exportieren(aktor_leser.symbol_links), + "symbol_rechts": symbol_exportieren(aktor_leser.symbol_rechts), + }; + } + + + /** + * @author kcf + */ + export function aktor_leser_importieren(roh : any) : typ_aktor_leser + { + return ( + aktor_leser_erstellen + ( + richtung_importieren(roh["richtung"]), + symbol_importieren(roh["symbol_links"]), + symbol_importieren(roh["symbol_rechts"]) + ) + ); } } diff --git a/quelldatein/aufbau/aktoren/schreiber.ts b/quelldatein/aufbau/aktoren/schreiber.ts index 3a236d0..9ce0ea7 100644 --- a/quelldatein/aufbau/aktoren/schreiber.ts +++ b/quelldatein/aufbau/aktoren/schreiber.ts @@ -3,16 +3,16 @@ * Copyright (C) 2016 Christian Fraß * * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by + * it under the terms of the GNU General export function aktor_schreiber_License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * GNU General export function aktor_schreiber_License for more details. * - * You should have received a copy of the GNU General Public License + * You should have received a copy of the GNU General export function aktor_schreiber_License * along with this program. If not, see . */ @@ -22,99 +22,87 @@ module mod_vtm_aufbau /** * @author kcf */ - export class klasse_schreiber - implements schnittstelle_aktor + export type typ_aktor_schreiber = { - - /** - * @author kcf - */ - private richtung : typ_richtung; - - - /** - * @author kcf - */ - private symbol : typ_symbol; - - - /** - * @author kcf - */ - public constructor(richtung : typ_richtung = 0, symbol : typ_symbol = 0) - { - this.richtung = richtung; - this.symbol = symbol; - } - - - /** - * @author kcf - */ - public richtung_lesen() : typ_richtung - { - return this.richtung; - } - - - /** - * @author kcf - */ - public symbol_lesen() : typ_symbol - { - return this.symbol; - } - - - /** - * @author kcf - * @implementation - */ - public drehen(inkrement : int = +1) : void - { - this.richtung = richtung_addieren(this.richtung, inkrement); - } - - - /** - * @author kcf - * @implementation - */ - public verwenden(figur : klasse_figur) : void - { - figur.schreiben(this.symbol); - figur.bewegen(this.richtung); - } - - - /** - * @author kcf - * @implementation - */ - public exportieren() : any - { - return { - "richtung": richtung_exportieren(this.richtung), - "symbol": symbol_exportieren(this.symbol), - }; - } - - - /** - * @author kcf - * @implementation - */ - public static importieren(roh : any) : klasse_schreiber - { - return ( - new klasse_schreiber - ( - richtung_importieren(roh["richtung"]), - symbol_importieren(roh["symbol"]) - ) - ); - } - + richtung : typ_richtung; + symbol : typ_symbol; + } + ; + + + /** + * @author kcf + */ + export function aktor_schreiber_erstellen(richtung : typ_richtung = 0, symbol : typ_symbol = 0) : typ_aktor_schreiber + { + return { + "richtung": richtung, + "symbol": symbol, + } + } + + + /** + * @author kcf + */ + export function aktor_schreiber_richtung_lesen(aktor_schreiber : typ_aktor_schreiber) : typ_richtung + { + return aktor_schreiber.richtung; + } + + + /** + * @author kcf + */ + export function aktor_schreiber_symbol_lesen(aktor_schreiber : typ_aktor_schreiber) : typ_symbol + { + return aktor_schreiber.symbol; + } + + + /** + * @author kcf + */ + export function aktor_schreiber_drehen(aktor_schreiber : typ_aktor_schreiber, inkrement : int = +1) : void + { + aktor_schreiber.richtung = richtung_addieren(aktor_schreiber.richtung, inkrement); + } + + + /** + * @author kcf + */ + export function aktor_schreiber_verwenden(aktor_schreiber : typ_aktor_schreiber, figur : typ_figur) : void + { + figur_schreiben(figur, aktor_schreiber.symbol); + figur_bewegen(figur, aktor_schreiber.richtung); + } + + + /** + * @author kcf + */ + export function aktor_schreiber_exportieren(aktor_schreiber : typ_aktor_schreiber) : any + { + return { + "richtung": richtung_exportieren(aktor_schreiber.richtung), + "symbol": symbol_exportieren(aktor_schreiber.symbol), + }; + } + + + /** + * @author kcf + */ + export function aktor_schreiber_importieren(roh : any) : typ_aktor_schreiber + { + return ( + aktor_schreiber_erstellen + ( + richtung_importieren(roh["richtung"]), + symbol_importieren(roh["symbol"]) + ) + ); } } diff --git a/quelldatein/aufbau/aktoren/verwerfer.ts b/quelldatein/aufbau/aktoren/verwerfer.ts index d837a94..4808e8c 100644 --- a/quelldatein/aufbau/aktoren/verwerfer.ts +++ b/quelldatein/aufbau/aktoren/verwerfer.ts @@ -3,16 +3,16 @@ * Copyright (C) 2016 Christian Fraß * * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by + * it under the terms of the GNU General export function aktor_verwerfer_License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * GNU General export function aktor_verwerfer_License for more details. * - * You should have received a copy of the GNU General Public License + * You should have received a copy of the GNU General export function aktor_verwerfer_License * along with this program. If not, see . */ @@ -22,61 +22,59 @@ module mod_vtm_aufbau /** * @author kcf */ - export class klasse_verwerfer - implements schnittstelle_aktor + export type typ_aktor_verwerfer = { - - /** - * @author kcf - */ - public constructor() - { - } - - - /** - * @author kcf - * @implementation - */ - public drehen(inkrement ?: int) : void - { - } - - - /** - * @author kcf - * @implementation - */ - public verwenden(figur : klasse_figur) : void - { - figur.verwerfen(); - } - - - /** - * @author kcf - * @implementation - */ - public exportieren() : any - { - return { - }; - } - - - /** - * @author kcf - * @implementation - */ - public static importieren(roh : any) : klasse_verwerfer - { - return ( - new klasse_verwerfer - ( - ) - ); - } - + } + ; + + + /** + * @author kcf + */ + export function aktor_verwerfer_erstellen() : typ_aktor_verwerfer + { + return { + }; + } + + + /** + * @author kcf + */ + export function aktor_verwerfer_drehen(aktor_verwerfer : typ_aktor_verwerfer, inkrement ?: int) : void + { + } + + + /** + * @author kcf + */ + export function aktor_verwerfer_verwenden(aktor_verwerfer : typ_aktor_verwerfer, figur : typ_figur) : void + { + figur_verwerfen(figur); + } + + + /** + * @author kcf + */ + export function aktor_verwerfer_exportieren(aktor_verwerfer : typ_aktor_verwerfer) : any + { + return { + }; + } + + + /** + * @author kcf + */ + export function aktor_verwerfer_importieren(roh : any) : typ_aktor_verwerfer + { + return ( + aktor_verwerfer_erstellen + ( + ) + ); } } diff --git a/quelldatein/aufbau/figur.ts b/quelldatein/aufbau/figur.ts index 7961acb..92a890c 100644 --- a/quelldatein/aufbau/figur.ts +++ b/quelldatein/aufbau/figur.ts @@ -3,16 +3,16 @@ * Copyright (C) 2016 Christian Fraß * * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by + * it under the terms of the GNU General export function figur_License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * GNU General export function figur_License for more details. * - * You should have received a copy of the GNU General Public License + * You should have received a copy of the GNU General export function figur_License * along with this program. If not, see . */ @@ -22,134 +22,165 @@ module mod_vtm_aufbau /** * @author kcf */ - export class klasse_figur + export type typ_figur = { - - /** - * @author kcf - */ - private zustand : typ_zustand; - - - /** - * @author kcf - */ - private band : Array; - - - /** - * @author kcf - */ - private stelle : typ_stelle; - - - /** - * @author kcf - */ - public constructor(band : Array = [], stelle : typ_stelle = stelle_null()) + zustand : typ_zustand; + band : Array; + stelle : typ_stelle; + } + ; + + + /** + * @author kcf + */ + export function figur_erstellen + ( + band : Array = [], + stelle : typ_stelle = stelle_null() + ) + : typ_figur + { + return { + "zustand": zustand_laufend, + "band": band, + "stelle": stelle, + }; + } + + + /** + * @author kcf + */ + export function figur_zustand_lesen + ( + figur : typ_figur + ) + : typ_zustand + { + return figur.zustand; + } + + + /** + * @author kcf + */ + export function figur_band_lesen + ( + figur : typ_figur + ) + : Array + { + return figur.band; + } + + + /** + * @author kcf + */ + export function figur_stelle_lesen + ( + figur : typ_figur + ) + : typ_stelle + { + return figur.stelle; + } + + + /** + * @author kcf + */ + export function figur_bewegen + ( + figur : typ_figur, + richtung : typ_richtung + ) + : void + { + let summand : typ_stelle = stelle_von_richtung(richtung); + figur.stelle = stelle_addieren(figur.stelle, summand); + } + + + /** + * @author kcf + */ + export function figur_schreiben + ( + figur : typ_figur, + symbol : typ_symbol + ) + : void + { + figur.band.push(symbol); + } + + + /** + * @author kcf + */ + export function figur_lesen + ( + figur : typ_figur + ) + : schnittstelle_fehlermonade + { + if (figur.band.length <= 0) { - this.zustand = zustand_laufend; - this.band = band; - this.stelle = stelle; + return (new klasse_nichts()); } - - - /** - * @author kcf - */ - public zustand_lesen() : typ_zustand + else { - return this.zustand; + return (new klasse_schlicht(figur.band[0])); } - - - /** - * @author kcf - */ - public band_lesen() : Array + } + + + /** + * @author kcf + */ + export function figur_schieben + ( + figur : typ_figur + ) + : void + { + if (figur.band.length <= 0) { - return this.band; + let meldung : string = "Band ist leer"; + throw (new Error(meldung)); } - - - /** - * @author kcf - */ - public stelle_lesen() : typ_stelle + else { - return this.stelle; + figur.band.shift(); } - - - /** - * @author kcf - */ - public bewegen(richtung : typ_richtung) : void - { - let summand : typ_stelle = stelle_von_richtung(richtung); - this.stelle = stelle_addieren(this.stelle, summand); - } - - - /** - * @author kcf - */ - public schreiben(symbol : typ_symbol) : void - { - this.band.push(symbol); - } - - - /** - * @author kcf - */ - public lesen() : schnittstelle_fehlermonade - { - if (this.band.length <= 0) - { - return (new klasse_nichts()); - } - else - { - return (new klasse_schlicht(this.band[0])); - } - } - - - /** - * @author kcf - */ - public schieben() : void - { - if (this.band.length <= 0) - { - let meldung : string = "Band ist leer"; - throw (new Error(meldung)); - } - else - { - this.band.shift(); - } - } - - - /** - * @author kcf - */ - public annehmen() : void - { - this.zustand = zustand_angenommen; - } - - - /** - * @author kcf - */ - public verwerfen() : void - { - this.zustand = zustand_abgelehnt; - } - + } + + + /** + * @author kcf + */ + export function figur_annehmen + ( + figur : typ_figur + ) + : void + { + figur.zustand = zustand_angenommen; + } + + + /** + * @author kcf + */ + export function figur_verwerfen + ( + figur : typ_figur + ) + : void + { + figur.zustand = zustand_abgelehnt; } } diff --git a/quelldatein/aufbau/partie.ts b/quelldatein/aufbau/partie.ts index 4a546f5..2901ec3 100644 --- a/quelldatein/aufbau/partie.ts +++ b/quelldatein/aufbau/partie.ts @@ -3,16 +3,16 @@ * Copyright (C) 2016 Christian Fraß * * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by + * it under the terms of the GNU General export function partie_License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * GNU General export function partie_License for more details. * - * You should have received a copy of the GNU General Public License + * You should have received a copy of the GNU General export function partie_License * along with this program. If not, see . */ @@ -22,357 +22,339 @@ module mod_vtm_aufbau /** * @author kcf */ - export class klasse_partie + export type typ_partie = { - - /** - * @author kcf - */ - private welt : klasse_welt; - - - /** - * @author kcf - */ - private figur : schnittstelle_fehlermonade; - - - /** - * @author kcf - */ - private aufgabe : schnittstelle_aufgabe; - - - /** - * @author kcf - */ - private testindex : schnittstelle_fehlermonade; - - - /** - * @author kcf - */ - private modus : typ_modus; - - - /** - * @author kcf - */ - private lauscher : {[ereignis : string] : Array<(angaben ?: any)=>void>}; - - - /** - * @author kcf - */ - public constructor - ( - aufgabe : schnittstelle_aufgabe - ) - { - this.aufgabe = aufgabe; - this.welt_leeren(false); - this.zuruecksetzen(false); - this.lauscher = { - "aenderung_aufgabe": [], - "aenderung_welt": [], - "aenderung_figur": [], - "aenderung_modus": [], - }; - } - - - /** - * @author kcf - */ - public lauschen(ereignis : string, prozedur : (angaben ?: any)=>void) : void - { - if (ereignis in this.lauscher) - { - this.lauscher[ereignis].push(prozedur); - } - else - { - let meldung : string = "kein Ereignis mit diesem Name"; - throw (new Error(meldung)); - } - } - + welt : typ_welt; + figur : schnittstelle_fehlermonade; + aufgabe : schnittstelle_aufgabe; + testindex : schnittstelle_fehlermonade; + modus : typ_modus; + lauscher : {[ereignis : string] : Array<(angaben ?: any)=>void>}; + } + ; + - /** - * @author kcf - */ - private benachrichtigen(ereignis : string, angaben : any = {}) : void + /** + * @author kcf + */ + export function partie_erstellen + ( + aufgabe : schnittstelle_aufgabe + ) + : typ_partie + { + let partie : typ_partie = { + "welt": undefined, + "figur": undefined, + "aufgabe": aufgabe, + "testindex": undefined, + "modus": undefined, + "lauscher": undefined, + }; + partie.lauscher = { + "aenderung_aufgabe": [], + "aenderung_welt": [], + "aenderung_figur": [], + "aenderung_modus": [], + }; + partie_welt_leeren(partie, false); + partie_zuruecksetzen(partie, false); + return partie; + } + + + /** + * @author kcf + */ + export function partie_lauschen(partie : typ_partie, ereignis : string, prozedur : (angaben ?: any)=>void) : void + { + if (ereignis in partie.lauscher) { - if (ereignis in this.lauscher) - { - this.lauscher[ereignis].forEach - ( - prozedur => - { - prozedur(angaben); - } - ) - ; - } - else - { - let meldung : string = "kein Ereignis mit diesem Name"; - throw (new Error(meldung)); - } + partie.lauscher[ereignis].push(prozedur); } - - - /** - * @author kcf - */ - public zuruecksetzen(bescheid_geben : boolean = true) : void + else { - this.figur = (new klasse_nichts()); - this.testindex = (new klasse_nichts()); - this.modus = modus_initial; - if (bescheid_geben) - { - this.benachrichtigen("aenderung_figur", {}); - this.benachrichtigen("aenderung_modus", {}); - } - else - { - // nichts tun - } + let meldung : string = "kein Ereignis mit diesem Name"; + throw (new Error(meldung)); } - - - /** - * @author kcf - */ - public aufgabe_lesen() : schnittstelle_aufgabe + } + + + /** + * @author kcf + */ + function partie_benachrichtigen(partie : typ_partie, ereignis : string, angaben : any = {}) : void + { + if (ereignis in partie.lauscher) { - return this.aufgabe; - } - - - /** - * @author kcf - */ - public aufgabe_setzen(aufgabe : schnittstelle_aufgabe) : void - { - this.aufgabe = aufgabe; - // this.welt_leeren(); - this.benachrichtigen("aenderung_aufgabe", {}); - this.zuruecksetzen(); - } - - - /** - * @author kcf - */ - public welt_lesen() : klasse_welt - { - return this.welt; - } - - - /** - * @author kcf - */ - public welt_setzen(welt : mod_vtm_aufbau.klasse_welt, bescheid_geben : boolean = true) : void - { - this.welt = welt; - if (bescheid_geben) - { - this.benachrichtigen("aenderung_welt", {}); - } - else - { - // nichts tun - } - } - - - /** - * @author kcf - */ - public welt_leeren(bescheid_geben : boolean = true) : void - { - this.welt = klasse_welt.blanko(); - if (bescheid_geben) - { - this.benachrichtigen("aenderung_welt", {}); - } - else - { - // nichts tun - } - } - - - /** - * @author kcf - */ - public figur_lesen() : schnittstelle_fehlermonade - { - return this.figur; - } - - - /** - * @author kcf - */ - public modus_lesen() : typ_modus - { - return this.modus; - } - - - /** - * @author kcf - */ - public welt_feld_wechseln(stelle : typ_stelle, umgekehrt : boolean = false) : void - { - if (! (this.modus === mod_vtm_aufbau.modus_initial)) - { - let meldung : string = "gesperrt"; - } - else - { - this.welt.feld_wechseln(stelle, umgekehrt); - this.benachrichtigen - ( - "aenderung_welt", - { - "art": "feld_wechseln", - "angaben": - { - "stelle": stelle, - "umgekehrt": umgekehrt, - "feld": this.welt.feld_holen(stelle), - } - } - ) - ; - } - } - - - /** - * @author kcf - */ - public welt_feld_drehen(stelle : typ_stelle, inkrement : int = +1) : void - { - if (! (this.modus === mod_vtm_aufbau.modus_initial)) - { - let meldung : string = "gesperrt"; - } - else - { - this.welt.feld_drehen(stelle, inkrement); - this.benachrichtigen("aenderung_welt", {}); - } - } - - - /** - * @author kcf - */ - public fortfahren() : void - { - switch (this.modus) - { - case modus_initial: + partie.lauscher[ereignis].forEach + ( + prozedur => { - this.modus = modus_ungewiss; - this.testindex = (new klasse_schlicht(0)); - this.benachrichtigen("aenderung_modus", {}); - break; + prozedur(angaben); } - case modus_ungewiss: + ) + ; + } + else + { + let meldung : string = "kein Ereignis mit diesem Name"; + throw (new Error(meldung)); + } + } + + + /** + * @author kcf + */ + export function partie_zuruecksetzen(partie : typ_partie, bescheid_geben : boolean = true) : void + { + partie.figur = (new klasse_nichts()); + partie.testindex = (new klasse_nichts()); + partie.modus = modus_initial; + if (bescheid_geben) + { + partie_benachrichtigen(partie, "aenderung_figur", {}); + partie_benachrichtigen(partie, "aenderung_modus", {}); + } + else + { + // nichts tun + } + } + + + /** + * @author kcf + */ + export function partie_aufgabe_lesen(partie : typ_partie) : schnittstelle_aufgabe + { + return partie.aufgabe; + } + + + /** + * @author kcf + */ + export function partie_aufgabe_setzen(partie : typ_partie, aufgabe : schnittstelle_aufgabe) : void + { + partie.aufgabe = aufgabe; + // partie.welt_leeren(); + partie_benachrichtigen(partie, "aenderung_aufgabe", {}); + partie_zuruecksetzen(partie); + } + + + /** + * @author kcf + */ + export function partie_welt_lesen(partie : typ_partie) : typ_welt + { + return partie.welt; + } + + + /** + * @author kcf + */ + export function partie_welt_setzen(partie : typ_partie, welt : mod_vtm_aufbau.typ_welt, bescheid_geben : boolean = true) : void + { + partie.welt = welt; + if (bescheid_geben) + { + partie_benachrichtigen(partie, "aenderung_welt", {}); + } + else + { + // nichts tun + } + } + + + /** + * @author kcf + */ + export function partie_welt_leeren(partie : typ_partie, bescheid_geben : boolean = true) : void + { + partie.welt = welt_blanko(); + if (bescheid_geben) + { + partie_benachrichtigen(partie, "aenderung_welt", {}); + } + else + { + // nichts tun + } + } + + + /** + * @author kcf + */ + export function partie_figur_lesen(partie : typ_partie) : schnittstelle_fehlermonade + { + return partie.figur; + } + + + /** + * @author kcf + */ + export function partie_modus_lesen(partie : typ_partie) : typ_modus + { + return partie.modus; + } + + + /** + * @author kcf + */ + export function partie_welt_feld_wechseln(partie : typ_partie, stelle : typ_stelle, umgekehrt : boolean = false) : void + { + if (! (partie.modus === mod_vtm_aufbau.modus_initial)) + { + let meldung : string = "gesperrt"; + } + else + { + welt_feld_wechseln(partie.welt, stelle, umgekehrt); + partie_benachrichtigen + ( + partie, + "aenderung_welt", + { + "art": "feld_wechseln", + "angaben": + { + "stelle": stelle, + "umgekehrt": umgekehrt, + "feld": welt_feld_holen(partie.welt, stelle), + } + } + ) + ; + } + } + + + /** + * @author kcf + */ + export function partie_welt_feld_drehen(partie : typ_partie, stelle : typ_stelle, inkrement : int = +1) : void + { + if (! (partie.modus === mod_vtm_aufbau.modus_initial)) + { + let meldung : string = "gesperrt"; + } + else + { + welt_feld_drehen(partie.welt, stelle, inkrement); + partie_benachrichtigen(partie, "aenderung_welt", {}); + } + } + + + /** + * @author kcf + */ + export function partie_fortfahren(partie : typ_partie) : void + { + switch (partie.modus) + { + case modus_initial: + { + partie.modus = modus_ungewiss; + partie.testindex = (new klasse_schlicht(0)); + partie_benachrichtigen(partie, "aenderung_modus", {}); + break; + } + case modus_ungewiss: + { + if (! partie.figur.ist_schlicht()) { - if (! this.figur.ist_schlicht()) - { - let test : schnittstelle_test = this.aufgabe.tests()[this.testindex.lesen()]; - let band : Array = mod_vtm_helfer.liste_kopieren(test.eingabe()); - let stelle : typ_stelle = this.welt.erzeuger_finden(); - this.figur = ( - new klasse_schlicht + let test : schnittstelle_test = partie.aufgabe.tests()[partie.testindex.lesen()]; + let band : Array = mod_vtm_helfer.liste_kopieren(test.eingabe()); + let stelle : typ_stelle = welt_erzeuger_finden(partie.welt); + partie.figur = ( + new klasse_schlicht + ( + figur_erstellen ( - new klasse_figur - ( - band, - stelle - ) + band, + stelle ) - ); - } - else + ) + ); + } + else + { + let figur : typ_figur = partie.figur.lesen(); + let stelle : typ_stelle = figur_stelle_lesen(figur); + let aktor_ : schnittstelle_fehlermonade = welt_feld_holen(partie.welt, stelle); + let aktor : typ_aktor = (aktor_.ist_schlicht() ? aktor_.lesen() : aktor_erstellen("verwerfer", {})); + aktor_verwenden(aktor, figur); + let zustand : typ_zustand = figur_zustand_lesen(figur); + if (zustand === zustand_laufend) { - let figur : klasse_figur = this.figur.lesen(); - let stelle : typ_stelle = figur.stelle_lesen(); - let aktor_ : schnittstelle_fehlermonade = this.welt.feld_holen(stelle); - let aktor : schnittstelle_aktor = (aktor_.ist_schlicht() ? aktor_.lesen() : (new klasse_verwerfer())); - aktor.verwenden(figur); - let zustand : typ_zustand = figur.zustand_lesen(); - if (zustand === zustand_laufend) + // nichts tun + } + else if ((zustand === zustand_angenommen) || (zustand === zustand_abgelehnt)) + { + let angenommen : boolean = (zustand === zustand_angenommen); + let ausgabe : Array = figur_band_lesen(figur); + partie.figur = (new klasse_nichts()); + let testindex : int = partie.testindex.lesen(); + let tests : Array = partie.aufgabe.tests(); + let test : schnittstelle_test = tests[testindex]; + if (! test.pruefen(angenommen, ausgabe)) { - // nichts tun - } - else if ((zustand === zustand_angenommen) || (zustand === zustand_abgelehnt)) - { - let angenommen : boolean = (zustand === zustand_angenommen); - let ausgabe : Array = figur.band_lesen(); - this.figur = (new klasse_nichts()); - let testindex : int = this.testindex.lesen(); - let tests : Array = this.aufgabe.tests(); - let test : schnittstelle_test = tests[testindex]; - if (! test.pruefen(angenommen, ausgabe)) - { - this.modus = modus_fehlerhaft; - this.benachrichtigen("aenderung_modus", {}); - } - else - { - testindex += 1; - if (testindex < tests.length) - { - // nächsten Test auswählen - this.testindex = (new klasse_schlicht(testindex)); - } - else - { - // auf Modus "korrekt" wechseln - this.testindex = (new klasse_nichts()); - this.modus = modus_korrekt; - this.benachrichtigen("aenderung_modus", {}); - } - } + partie.modus = modus_fehlerhaft; + partie_benachrichtigen(partie, "aenderung_modus", {}); } else { - let meldung : string = "unbehandelter Zustand"; - throw (new Error(meldung)); + testindex += 1; + if (testindex < tests.length) + { + // nächsten Test auswählen + partie.testindex = (new klasse_schlicht(testindex)); + } + else + { + // auf Modus "korrekt" wechseln + partie.testindex = (new klasse_nichts()); + partie.modus = modus_korrekt; + partie_benachrichtigen(partie, "aenderung_modus", {}); + } } } - this.benachrichtigen("aenderung_figur", {}); - break; - } - case modus_fehlerhaft: - { - // nichts tun - break; - } - case modus_korrekt: - { - // nichts tun - break; - } - default: - { - let meldung : string = "unbehandelter Modus"; - throw (new Error(meldung)); - break; + else + { + let meldung : string = "unbehandelter Zustand"; + throw (new Error(meldung)); + } } + partie_benachrichtigen(partie, "aenderung_figur", {}); + break; + } + case modus_fehlerhaft: + { + // nichts tun + break; + } + case modus_korrekt: + { + // nichts tun + break; + } + default: + { + let meldung : string = "unbehandelter Modus"; + throw (new Error(meldung)); + break; } } - + } } diff --git a/quelldatein/aufbau/welt.ts b/quelldatein/aufbau/welt.ts index e9ed907..31bcb2f 100644 --- a/quelldatein/aufbau/welt.ts +++ b/quelldatein/aufbau/welt.ts @@ -3,16 +3,16 @@ * Copyright (C) 2016 Christian Fraß * * This program is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by + * it under the terms of the GNU General export function welt_License as published by * the Free Software Foundation, either version 3 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. + * GNU General export function welt_License for more details. * - * You should have received a copy of the GNU General Public License + * You should have received a copy of the GNU General export function welt_License * along with this program. If not, see . */ @@ -22,89 +22,120 @@ module mod_vtm_aufbau /** * @author kcf */ - export class klasse_welt + export type typ_welt = { - - /** - * @author kcf - */ - private felder : mod_vtm_helfer.klasse_hashmap; - - - /** - * @author kcf - */ - public constructor + felder : mod_vtm_helfer.klasse_hashmap; + } + ; + + + /** + * @author kcf + */ + export function welt_erstellen + ( + felder : mod_vtm_helfer.klasse_hashmap = (new mod_vtm_helfer.klasse_hashmap(stelle_hash)) + ) + : typ_welt + { + return { + "felder": felder, + }; + } + + + /** + * @author kcf + */ + export function welt_felder_lesen(welt : typ_welt) : Array<{stelle : typ_stelle; aktor : typ_aktor;}> + { + let felder : Array<{stelle : typ_stelle; aktor : typ_aktor;}> = []; + welt.felder.iterieren ( - felder : mod_vtm_helfer.klasse_hashmap = (new mod_vtm_helfer.klasse_hashmap(stelle_hash)) + (stelle, aktor) => felder.push({"stelle": stelle, "aktor": aktor}) ) - { - this.felder = felder; - } - - - /** - * @author kcf - */ - public felder_lesen() : Array<{stelle : typ_stelle; aktor : schnittstelle_aktor;}> - { - let felder : Array<{stelle : typ_stelle; aktor : schnittstelle_aktor;}> = []; - this.felder.iterieren - ( - (stelle, aktor) => felder.push({"stelle": stelle, "aktor": aktor}) - ) - ; - return felder; - } - - - /** - * @author kcf - */ - public feld_holen(stelle : typ_stelle) : schnittstelle_fehlermonade - { - return this.felder.holen(stelle); - } - - - /** - * @author kcf - */ - public feld_setzen(stelle : typ_stelle, aktor : schnittstelle_aktor) : void - { - this.felder.setzen(stelle, aktor); - } - - - /** - * @author kcf - */ - public feld_wechseln(stelle : typ_stelle, umgekehrt : boolean = false) : void - { - let erweitert : boolean = true; - let liste : Array<{pruefer : (aktor : schnittstelle_aktor)=>boolean; ersteller : ()=>schnittstelle_aktor;}> = ( - [] - .concat + ; + return felder; + } + + + /** + * @author kcf + */ + export function welt_feld_holen(welt : typ_welt, stelle : typ_stelle) : schnittstelle_fehlermonade + { + return welt.felder.holen(stelle); + } + + + /** + * @author kcf + */ + export function welt_feld_setzen(welt : typ_welt, stelle : typ_stelle, aktor : typ_aktor) : void + { + welt.felder.setzen(stelle, aktor); + } + + + /** + * @author kcf + */ + export function welt_feld_wechseln(welt : typ_welt, stelle : typ_stelle, umgekehrt : boolean = false) : void + { + let erweitert : boolean = true; + let liste : Array<{pruefer : (aktor : typ_aktor)=>boolean; ersteller : ()=>typ_aktor;}> = ( + [] + .concat + ( + [ + { + "pruefer": (aktor) => (aktor.art === "befoerderer"), + "ersteller": () => aktor_erstellen("befoerderer"), + }, + ] + ) + .concat + ( + mod_vtm_helfer.sequenz(erweitert ? 4 : 2).map ( - [ + symbol => ( { - "pruefer": (aktor) => (aktor instanceof klasse_befoerderer), - "ersteller": () => new klasse_befoerderer(), - }, - ] + "pruefer": (aktor) => + { + if (aktor.art === "schreiber") + { + return (aktor_schreiber_symbol_lesen(aktor.angaben) === symbol); + } + else + { + return false; + } + } + , + "ersteller": () => aktor_erstellen("schreiber", {"richtung": 0, "symbol": symbol}) + } + ) ) - .concat + ) + .concat + ( + mod_vtm_helfer.sequenz(erweitert ? 2 : 1).map ( - mod_vtm_helfer.sequenz(erweitert ? 4 : 2).map - ( - symbol => ( + index => + { + let symbol_links : typ_symbol = (2*index+0); + let symbol_rechts : typ_symbol = (2*index+1); + return ( { "pruefer": (aktor) => { - if (aktor instanceof klasse_schreiber) + if (aktor.art === "leser") { - let schreiber : klasse_schreiber = (aktor); - return (schreiber.symbol_lesen() === symbol); + return ( + (aktor_leser_symbol_links_lesen(aktor.angaben) === symbol_links) + && + (aktor_leser_symbol_links_lesen(aktor.angaben) === symbol_rechts) + ); } else { @@ -112,236 +143,202 @@ module mod_vtm_aufbau } } , - "ersteller": () => new klasse_schreiber(0, symbol), + "ersteller": () => aktor_erstellen("leser", {"richtung": 0, "symbol_links": symbol_links, "symbol_rechts": (2*index+1)}), } - ) - ) + ); + } ) - .concat - ( - mod_vtm_helfer.sequenz(erweitert ? 2 : 1).map - ( - index => - { - let symbol_links : typ_symbol = (2*index+0); - let symbol_rechts : typ_symbol = (2*index+1); - return ( - { - "pruefer": (aktor) => - { - if (aktor instanceof klasse_leser) - { - let leser : klasse_leser = (aktor); - return ( - (leser.symbol_links_lesen() === symbol_links) - && - (leser.symbol_rechts_lesen() === symbol_rechts) - ); - } - else - { - return false; - } - } - , - "ersteller": () => new klasse_leser(0, symbol_links, 2*index+1), - } - ); - } - ) - ) - .concat - ( - [ - { - "pruefer": (aktor) => (aktor instanceof klasse_verwerfer), - "ersteller": () => new klasse_verwerfer(), - }, - ] - ) - ); - let index_alt : schnittstelle_fehlermonade; - let aktor_alt_ : schnittstelle_fehlermonade = this.felder.holen(stelle); - if (aktor_alt_.ist_schlicht) - { - let aktor_alt : schnittstelle_aktor = aktor_alt_.lesen(); - let gefunden : boolean = liste.some - ( - (eintrag, index) => - { - if (eintrag.pruefer(aktor_alt)) - { - index_alt = (new klasse_schlicht(index)); - return true; - } - else - { - return false; - } - } - ) - ; - if (! gefunden) - { - index_alt = (new klasse_nichts()); - } - else - { - // nichts tun - } - } - else - { - let meldung : string = "kein Aktor gesetzt"; - // console.warn(meldung); - index_alt = (new klasse_schlicht(0)); - } - if (index_alt.ist_schlicht()) - { - let index_neu : int = mod_vtm_helfer.mod(index_alt.lesen() + (umgekehrt ? -1 : +1), liste.length); - let aktor_neu : schnittstelle_aktor = liste[index_neu].ersteller(); - this.feld_setzen(stelle, aktor_neu); - } - else - { - let meldung : string = ("Aktor nicht gefunden"); - // throw (new Error(meldung)); - console.warn(meldung); - } - } - - - /** - * @author kcf - */ - public feld_drehen(stelle : typ_stelle, inkrement : int = +1) : void + ) + .concat + ( + [ + { + "pruefer": (aktor) => (aktor.art === "verwerfer"), + "ersteller": () => aktor_erstellen("verwerfer"), + }, + ] + ) + ); + let index_alt : schnittstelle_fehlermonade; + let aktor_alt_ : schnittstelle_fehlermonade = welt.felder.holen(stelle); + if (aktor_alt_.ist_schlicht) { - let aktor_ : schnittstelle_fehlermonade = this.felder.holen(stelle); - if (aktor_.ist_schlicht) + let aktor_alt : typ_aktor = aktor_alt_.lesen(); + let gefunden : boolean = liste.some + ( + (eintrag, index) => + { + if (eintrag.pruefer(aktor_alt)) + { + index_alt = (new klasse_schlicht(index)); + return true; + } + else + { + return false; + } + } + ) + ; + if (! gefunden) { - aktor_.lesen().drehen(inkrement); + index_alt = (new klasse_nichts()); } else { - console.warn("kein Aktor gesetzt"); + // nichts tun } } - + else + { + let meldung : string = "kein Aktor gesetzt"; + // console.warn(meldung); + index_alt = (new klasse_schlicht(0)); + } + if (index_alt.ist_schlicht()) + { + let index_neu : int = mod_vtm_helfer.mod(index_alt.lesen() + (umgekehrt ? -1 : +1), liste.length); + let aktor_neu : typ_aktor = liste[index_neu].ersteller(); + welt_feld_setzen(welt, stelle, aktor_neu); + } + else + { + let meldung : string = ("Aktor nicht gefunden"); + // throw (new Error(meldung)); + console.warn(meldung); + } + } + + + /** + * @author kcf + */ + export function welt_feld_drehen(welt : typ_welt, stelle : typ_stelle, inkrement : int = +1) : void + { + let aktor_ : schnittstelle_fehlermonade = welt.felder.holen(stelle); + if (aktor_.ist_schlicht) + { + aktor_drehen(aktor_.lesen(), inkrement); + } + else + { + console.warn("kein Aktor gesetzt"); + } + } + - /** - * @author kcf - * @throws {Error} - */ - public erzeuger_finden() : typ_stelle - { - let stelle : schnittstelle_fehlermonade = (new klasse_nichts()); - this.felder.iterieren - ( - (stelle_, aktor) => + /** + * @author kcf + * @throws {Error} + */ + export function welt_erzeuger_finden(welt : typ_welt) : typ_stelle + { + let stelle : schnittstelle_fehlermonade = (new klasse_nichts()); + welt.felder.iterieren + ( + (stelle_, aktor) => + { + if (aktor.art === "erzeuger") { - if (aktor instanceof klasse_erzeuger) + if (stelle.ist_schlicht()) { - if (stelle.ist_schlicht()) - { - let meldung : string = "mehrere Erzeuger gefunden"; - throw (new Error(meldung)); - } - else - { - stelle = (new klasse_schlicht(stelle_)); - } + let meldung : string = "mehrere Erzeuger gefunden"; + throw (new Error(meldung)); } - } - ) - ; - if (stelle.ist_schlicht()) - { - return stelle.lesen(); - } - else - { - let meldung : string = "kein Erzeuger gefunden"; - throw (new Error(meldung)); - } - } - - - /** - * @author kcf - */ - public static blanko(groesse : int = 3) : klasse_welt - { - let welt : klasse_welt = new klasse_welt(); - for (let u : int = -groesse; u <= +groesse; u += 1) - { - for (let v : int = -groesse; v <= +groesse; v += 1) - { - if (Math.abs(u-v) <= groesse) + else { - let stelle : typ_stelle = {"u": u, "v": v}; - let aktor : schnittstelle_aktor; - if ((u === -groesse) && (v === 0)) - { - aktor = (new klasse_erzeuger(0)); - } - else if ((u === +groesse) && (v === 0)) - { - aktor = (new klasse_annehmer()); - } - else - { - aktor = (new klasse_verwerfer()); - } - welt.felder.setzen(stelle, aktor); + stelle = (new klasse_schlicht(stelle_)); } } } - return welt; - } - - - /** - * @author kcf - */ - public exportieren() : any + ) + ; + if (stelle.ist_schlicht()) { - let roh : any = {}; - roh["felder"] = {}; - this.felder.iterieren - ( - (stelle, aktor) => - { - let stelle_ : string = stelle_exportieren(stelle); - let aktor_ : any = aktor_exportieren(aktor); - roh["felder"][stelle_] = aktor_; - } - ) - ; - return roh; + return stelle.lesen(); } - - - /** - * @author kcf - */ - public static importieren(roh : any) : klasse_welt + else { - let felder : mod_vtm_helfer.klasse_hashmap = (new mod_vtm_helfer.klasse_hashmap(stelle_hash)); - for (let stelle_ in roh["felder"]) + let meldung : string = "kein Erzeuger gefunden"; + throw (new Error(meldung)); + } + } + + + /** + * @author kcf + */ + export function welt_blanko(groesse : int = 3) : typ_welt + { + let welt : typ_welt = welt_erstellen(); + for (let u : int = -groesse; u <= +groesse; u += 1) + { + for (let v : int = -groesse; v <= +groesse; v += 1) { - let stelle : typ_stelle = stelle_importieren(stelle_); - let aktor_ : schnittstelle_aktor = roh["felder"][stelle_]; - let aktor : schnittstelle_aktor = aktor_importieren(aktor_); - felder.setzen(stelle, aktor); + if (Math.abs(u-v) <= groesse) + { + let stelle : typ_stelle = {"u": u, "v": v}; + let aktor : typ_aktor; + if ((u === -groesse) && (v === 0)) + { + aktor = aktor_erstellen("erzeuger", {"richtung": 0}); + } + else if ((u === +groesse) && (v === 0)) + { + aktor = aktor_erstellen("annehmer", {}); + } + else + { + aktor = aktor_erstellen("verwerfer", {}); + } + welt.felder.setzen(stelle, aktor); + } } - return ( - new klasse_welt - ( - felder - ) - ); } - + return welt; + } + + + /** + * @author kcf + */ + export function welt_exportieren(welt : typ_welt) : any + { + let roh : any = {}; + roh["felder"] = {}; + welt.felder.iterieren + ( + (stelle, aktor) => + { + let stelle_ : string = stelle_exportieren(stelle); + let aktor_ : any = aktor_exportieren(aktor); + roh["felder"][stelle_] = aktor_; + } + ) + ; + return roh; + } + + + /** + * @author kcf + */ + export function welt_importieren(roh : any) : typ_welt + { + let felder : mod_vtm_helfer.klasse_hashmap = (new mod_vtm_helfer.klasse_hashmap(stelle_hash)); + for (let stelle_ in roh["felder"]) + { + let stelle : typ_stelle = stelle_importieren(stelle_); + let aktor_ : typ_aktor = roh["felder"][stelle_]; + let aktor : typ_aktor = aktor_importieren(aktor_); + felder.setzen(stelle, aktor); + } + return ( + welt_erstellen + ( + felder + ) + ); } } diff --git a/quelldatein/haupt.ts b/quelldatein/haupt.ts index 14ed1b8..1e342e7 100644 --- a/quelldatein/haupt.ts +++ b/quelldatein/haupt.ts @@ -115,27 +115,27 @@ function haupt() : void let hoehe : float = 80; [ { - "aufbau": (new mod_vtm_aufbau.klasse_erzeuger()), + "aufbau": mod_vtm_aufbau.aktor_erstellen("erzeuger"), "bereich": document.querySelector("#hilfe_aktoren_aktor_erzeuger"), }, { - "aufbau": (new mod_vtm_aufbau.klasse_annehmer()), + "aufbau": mod_vtm_aufbau.aktor_erstellen("annehmer"), "bereich": document.querySelector("#hilfe_aktoren_aktor_annehmer"), }, { - "aufbau": (new mod_vtm_aufbau.klasse_verwerfer()), + "aufbau": mod_vtm_aufbau.aktor_erstellen("verwerfer"), "bereich": document.querySelector("#hilfe_aktoren_aktor_verwerfer"), }, { - "aufbau": (new mod_vtm_aufbau.klasse_befoerderer()), + "aufbau": mod_vtm_aufbau.aktor_erstellen("befoerderer"), "bereich": document.querySelector("#hilfe_aktoren_aktor_befoerderer"), }, { - "aufbau": (new mod_vtm_aufbau.klasse_schreiber()), + "aufbau": mod_vtm_aufbau.aktor_erstellen("schreiber"), "bereich": document.querySelector("#hilfe_aktoren_aktor_schreiber"), }, { - "aufbau": (new mod_vtm_aufbau.klasse_leser()), + "aufbau": mod_vtm_aufbau.aktor_erstellen("leser"), "bereich": document.querySelector("#hilfe_aktoren_aktor_leser"), }, ] @@ -154,13 +154,13 @@ function haupt() : void } // Spiel { - let aufbau : mod_vtm_aufbau.klasse_partie; + let aufbau : mod_vtm_aufbau.typ_partie; aufgaben_eintragen ( - function (aufgabe : mod_vtm_aufbau.schnittstelle_aufgabe) : void {aufbau.aufgabe_setzen(aufgabe);} + function (aufgabe : mod_vtm_aufbau.schnittstelle_aufgabe) : void {mod_vtm_aufbau.partie_aufgabe_setzen(aufbau, aufgabe);} ) ; - aufbau = (new mod_vtm_aufbau.klasse_partie(mod_vtm_aufbau.aufgabe_holen(0))); + aufbau = mod_vtm_aufbau.partie_erstellen(mod_vtm_aufbau.aufgabe_holen(0)); (new mod_vtm_manifestation.klasse_web_partie(aufbau, document.querySelector("#bereich_mitte"))).einrichten(); (new mod_vtm_manifestation.klasse_speicher_partie(aufbau)).einrichten(); } diff --git a/quelldatein/manifestation/speicher/partie.ts b/quelldatein/manifestation/speicher/partie.ts index 6f4cf07..ea2393b 100644 --- a/quelldatein/manifestation/speicher/partie.ts +++ b/quelldatein/manifestation/speicher/partie.ts @@ -23,13 +23,13 @@ module mod_vtm_manifestation * @author kcf */ export class klasse_speicher_partie - extends klasse_manifestation + extends klasse_manifestation { /** * @author kcf */ - public constructor(aufbau : mod_vtm_aufbau.klasse_partie) + public constructor(aufbau : mod_vtm_aufbau.typ_partie) { super(aufbau); } @@ -41,42 +41,45 @@ module mod_vtm_manifestation */ public einrichten() : void { - this.aufbau.lauschen + mod_vtm_aufbau.partie_lauschen ( + this.aufbau, "aenderung_aufgabe", (angaben) => { // console.info("aenderung_aufgabe", angaben); - let id : string = this.aufbau.aufgabe_lesen().id_lesen(); + let id : string = mod_vtm_aufbau.partie_aufgabe_lesen(this.aufbau).id_lesen(); let key : string = ("vtm_" + id); if (key in localStorage) { let item : string = localStorage.getItem(key); - let welt : mod_vtm_aufbau.klasse_welt = mod_vtm_aufbau.klasse_welt.importieren(JSON.parse(item)); - this.aufbau.welt_setzen(welt, false); + let welt : mod_vtm_aufbau.typ_welt = mod_vtm_aufbau.welt_importieren(JSON.parse(item)); + mod_vtm_aufbau.partie_welt_setzen(this.aufbau, welt, false); } else { - this.aufbau.welt_leeren(); + mod_vtm_aufbau.partie_welt_leeren(this.aufbau); // nichts tun } } ) ; - this.aufbau.lauschen + mod_vtm_aufbau.partie_lauschen ( + this.aufbau, "aenderung_welt", (angaben) => { - let id : string = this.aufbau.aufgabe_lesen().id_lesen(); + let id : string = mod_vtm_aufbau.partie_aufgabe_lesen(this.aufbau).id_lesen(); let key : string = ("vtm_" + id); - let item : string = JSON.stringify(this.aufbau.welt_lesen().exportieren()); + let item : string = JSON.stringify(mod_vtm_aufbau.welt_exportieren(mod_vtm_aufbau.partie_welt_lesen(this.aufbau))); localStorage.setItem(key, item); } ) ; - this.aufbau.lauschen + mod_vtm_aufbau.partie_lauschen ( + this.aufbau, "aenderung_figur", (angaben) => { @@ -84,8 +87,9 @@ module mod_vtm_manifestation } ) ; - this.aufbau.lauschen + mod_vtm_aufbau.partie_lauschen ( + this.aufbau, "aenderung_modus", (angaben) => { diff --git a/quelldatein/manifestation/svg/aktor.ts b/quelldatein/manifestation/svg/aktor.ts index bec12c5..afaaa0c 100644 --- a/quelldatein/manifestation/svg/aktor.ts +++ b/quelldatein/manifestation/svg/aktor.ts @@ -23,7 +23,7 @@ module mod_vtm_manifestation * @author kcf */ export class klasse_svg_aktor - extends klasse_manifestation + extends klasse_manifestation { /** @@ -35,7 +35,7 @@ module mod_vtm_manifestation /** * @author kcf */ - public constructor(aufbau : mod_vtm_aufbau.schnittstelle_aktor, stelle : mod_vtm_aufbau.typ_stelle) + public constructor(aufbau : mod_vtm_aufbau.typ_aktor, stelle : mod_vtm_aufbau.typ_stelle) { super(aufbau); this.stelle = stelle; @@ -48,7 +48,7 @@ module mod_vtm_manifestation */ public darstellen() : mod_vtm_helfer.schnittstelle_xmlknoten { - let aktor : mod_vtm_aufbau.schnittstelle_aktor = this.aufbau; + let aktor : mod_vtm_aufbau.typ_aktor = this.aufbau; let knoten_rahmen = function () : mod_vtm_helfer.schnittstelle_xmlknoten { return ( @@ -64,202 +64,208 @@ module mod_vtm_manifestation } ; let kinder_feld : Array = []; - if (aktor instanceof mod_vtm_aufbau.klasse_erzeuger) + switch (aktor.art) { - kinder_feld.push(knoten_rahmen()); - let erzeuger : mod_vtm_aufbau.klasse_erzeuger = (aktor); - let richtung : mod_vtm_aufbau.typ_richtung = erzeuger.richtung_lesen(); - let knoten_pfeil : mod_vtm_helfer.schnittstelle_xmlknoten = ( - new mod_vtm_helfer.klasse_xmlknoten_normal - ( - "path", - { - "d": svg_form_pfeil, - "class": ( - [ - "pfeil", - "erzeuger", - ].join(" ") - ), - "transform": ( - [ - "rotate(" + ((richtung/6.0) * 360).toFixed(svg_float_praezission) + ")", - "translate(-0.2, 0)", - "scale(0.12)", - ].join(" ") - ), - } - ) - ); - kinder_feld.push(knoten_pfeil); - } - else if (aktor instanceof mod_vtm_aufbau.klasse_befoerderer) - { - kinder_feld.push(knoten_rahmen()); - let befoerderer : mod_vtm_aufbau.klasse_befoerderer = (aktor); - let richtung : mod_vtm_aufbau.typ_richtung = befoerderer.richtung_lesen(); - let knoten_pfeil : mod_vtm_helfer.schnittstelle_xmlknoten = ( - new mod_vtm_helfer.klasse_xmlknoten_normal - ( - "path", - { - "d": svg_form_pfeil, - "class": ( - [ - "pfeil", - "neutral", - ].join(" ") - ), - "transform": ( - [ - "rotate(" + ((richtung/6.0) * 360).toFixed(svg_float_praezission) + ")", - "translate(-0.2, 0)", - "scale(0.12)", - ].join(" ") - ), - } - ) - ); - kinder_feld.push(knoten_pfeil); - } - else if (aktor instanceof mod_vtm_aufbau.klasse_schreiber) - { - kinder_feld.push(knoten_rahmen()); - let schreiber : mod_vtm_aufbau.klasse_schreiber = (aktor); - let richtung : mod_vtm_aufbau.typ_richtung = schreiber.richtung_lesen(); - let symbol : mod_vtm_aufbau.typ_symbol = schreiber.symbol_lesen(); - let knoten_pfeil : mod_vtm_helfer.schnittstelle_xmlknoten = ( - new mod_vtm_helfer.klasse_xmlknoten_normal - ( - "path", - { - "d": svg_form_pfeil, - "class": ( - [ - "pfeil", - "symbol_" + symbol.toFixed(0), - ].join(" ") - ), - "transform": ( - [ - "rotate(" + ((richtung/6.0) * 360).toFixed(svg_float_praezission) + ")", - "translate(-0.2, 0)", - "scale(0.12)", - ].join(" ") - ), - } - ) - ); - kinder_feld.push(knoten_pfeil); - } - else if (aktor instanceof mod_vtm_aufbau.klasse_leser) - { - kinder_feld.push(knoten_rahmen()); - let leser : mod_vtm_aufbau.klasse_leser = (aktor); - let richtung : mod_vtm_aufbau.typ_richtung = leser.richtung_lesen(); - let ausgaenge : Array<{summand : mod_vtm_aufbau.typ_richtung, symbol : schnittstelle_fehlermonade;}> = - [ - { - "summand": 0, - "symbol": new klasse_nichts(), - }, - { - "summand": +2, - "symbol": new klasse_schlicht(leser.symbol_links_lesen()), - }, - { - "summand": -2, - "symbol": new klasse_schlicht(leser.symbol_rechts_lesen()), - }, - ] - ; - ausgaenge.forEach - ( - eintrag => - { - let winkel : float = ((mod_vtm_aufbau.richtung_addieren(richtung, eintrag.summand) / 6.0) * 360); - let knoten_pfeil : mod_vtm_helfer.schnittstelle_xmlknoten = ( - new mod_vtm_helfer.klasse_xmlknoten_normal - ( - "path", - { - "d": svg_form_pfeil, - "class": ( - [ - "pfeil", - ( - eintrag.symbol.ist_schlicht() - ? "symbol_" + eintrag.symbol.lesen().toFixed(0) - : "neutral" + case "erzeuger": + { + kinder_feld.push(knoten_rahmen()); + let richtung : mod_vtm_aufbau.typ_richtung = mod_vtm_aufbau.aktor_erzeuger_richtung_lesen(aktor.angaben); + let knoten_pfeil : mod_vtm_helfer.schnittstelle_xmlknoten = ( + new mod_vtm_helfer.klasse_xmlknoten_normal + ( + "path", + { + "d": svg_form_pfeil, + "class": ( + [ + "pfeil", + "erzeuger", + ].join(" ") + ), + "transform": ( + [ + "rotate(" + ((richtung/6.0) * 360).toFixed(svg_float_praezission) + ")", + "translate(-0.2, 0)", + "scale(0.12)", + ].join(" ") + ), + } + ) + ); + kinder_feld.push(knoten_pfeil); + break; + } + case "befoerderer": + { + kinder_feld.push(knoten_rahmen()); + let richtung : mod_vtm_aufbau.typ_richtung = mod_vtm_aufbau.aktor_befoerderer_richtung_lesen(aktor.angaben); + let knoten_pfeil : mod_vtm_helfer.schnittstelle_xmlknoten = ( + new mod_vtm_helfer.klasse_xmlknoten_normal + ( + "path", + { + "d": svg_form_pfeil, + "class": ( + [ + "pfeil", + "neutral", + ].join(" ") + ), + "transform": ( + [ + "rotate(" + ((richtung/6.0) * 360).toFixed(svg_float_praezission) + ")", + "translate(-0.2, 0)", + "scale(0.12)", + ].join(" ") + ), + } + ) + ); + kinder_feld.push(knoten_pfeil); + break; + } + case "schreiber": + { + kinder_feld.push(knoten_rahmen()); + let richtung : mod_vtm_aufbau.typ_richtung = mod_vtm_aufbau.aktor_schreiber_richtung_lesen(aktor.angaben); + let symbol : mod_vtm_aufbau.typ_symbol = mod_vtm_aufbau.aktor_schreiber_symbol_lesen(aktor.angaben); + let knoten_pfeil : mod_vtm_helfer.schnittstelle_xmlknoten = ( + new mod_vtm_helfer.klasse_xmlknoten_normal + ( + "path", + { + "d": svg_form_pfeil, + "class": ( + [ + "pfeil", + "symbol_" + symbol.toFixed(0), + ].join(" ") + ), + "transform": ( + [ + "rotate(" + ((richtung/6.0) * 360).toFixed(svg_float_praezission) + ")", + "translate(-0.2, 0)", + "scale(0.12)", + ].join(" ") + ), + } + ) + ); + kinder_feld.push(knoten_pfeil); + break; + } + case "leser": + { + kinder_feld.push(knoten_rahmen()); + let richtung : mod_vtm_aufbau.typ_richtung = mod_vtm_aufbau.aktor_leser_richtung_lesen(aktor.angaben); + let symbol_links : mod_vtm_aufbau.typ_symbol = mod_vtm_aufbau.aktor_leser_symbol_links_lesen(aktor.angaben); + let symbol_rechts : mod_vtm_aufbau.typ_symbol = mod_vtm_aufbau.aktor_leser_symbol_rechts_lesen(aktor.angaben); + let ausgaenge : Array<{summand : mod_vtm_aufbau.typ_richtung, symbol : schnittstelle_fehlermonade;}> = + [ + { + "summand": 0, + "symbol": new klasse_nichts(), + }, + { + "summand": +2, + "symbol": new klasse_schlicht(symbol_links), + }, + { + "summand": -2, + "symbol": new klasse_schlicht(symbol_rechts), + }, + ] + ; + ausgaenge.forEach + ( + eintrag => + { + let winkel : float = ((mod_vtm_aufbau.richtung_addieren(richtung, eintrag.summand) / 6.0) * 360); + let knoten_pfeil : mod_vtm_helfer.schnittstelle_xmlknoten = ( + new mod_vtm_helfer.klasse_xmlknoten_normal + ( + "path", + { + "d": svg_form_pfeil, + "class": ( + [ + "pfeil", + ( + eintrag.symbol.ist_schlicht() + ? "symbol_" + eintrag.symbol.lesen().toFixed(0) + : "neutral" + ), + ].join(" ") ), - ].join(" ") - ), - "transform": ( - [ - - "rotate(" + winkel.toFixed(svg_float_praezission) + ")", - "translate(0.1, 0)", - "scale(0.075)", - ].join(" ") - ), - } - ) - ); - kinder_feld.push(knoten_pfeil); - } - ) - ; - } - else if (aktor instanceof mod_vtm_aufbau.klasse_verwerfer) - { - kinder_feld.push(knoten_rahmen()); - let verwerfer : mod_vtm_aufbau.klasse_annehmer = (aktor); - let knoten_kreis : mod_vtm_helfer.schnittstelle_xmlknoten = ( - new mod_vtm_helfer.klasse_xmlknoten_normal - ( - "circle", - { - "cx": (0.0).toFixed(svg_float_praezission), - "cy": (0.0).toFixed(svg_float_praezission), - "r": (0.25).toFixed(svg_float_praezission), - "class": ( - [ - "kreis", - "negativ", - ].join(" ") - ), - } - ) - ); - kinder_feld.push(knoten_kreis); - } - else if (aktor instanceof mod_vtm_aufbau.klasse_annehmer) - { - kinder_feld.push(knoten_rahmen()); - let annehmer : mod_vtm_aufbau.klasse_annehmer = (aktor); - let knoten_kreis : mod_vtm_helfer.schnittstelle_xmlknoten = ( - new mod_vtm_helfer.klasse_xmlknoten_normal - ( - "circle", - { - "cx": (0.0).toFixed(svg_float_praezission), - "cy": (0.0).toFixed(svg_float_praezission), - "r": (0.25).toFixed(svg_float_praezission), - "class": ( - [ - "kreis", - "positiv", - ].join(" ") - ), - } - ) - ); - kinder_feld.push(knoten_kreis); - } - else - { - let meldung : string = ("unbehandelter Aktor-Typ"); - throw (new Error(meldung)); + "transform": ( + [ + + "rotate(" + winkel.toFixed(svg_float_praezission) + ")", + "translate(0.1, 0)", + "scale(0.075)", + ].join(" ") + ), + } + ) + ); + kinder_feld.push(knoten_pfeil); + } + ) + ; + break; + } + case "verwerfer": + { + kinder_feld.push(knoten_rahmen()); + let knoten_kreis : mod_vtm_helfer.schnittstelle_xmlknoten = ( + new mod_vtm_helfer.klasse_xmlknoten_normal + ( + "circle", + { + "cx": (0.0).toFixed(svg_float_praezission), + "cy": (0.0).toFixed(svg_float_praezission), + "r": (0.25).toFixed(svg_float_praezission), + "class": ( + [ + "kreis", + "negativ", + ].join(" ") + ), + } + ) + ); + kinder_feld.push(knoten_kreis); + break; + } + case "annehmer": + { + kinder_feld.push(knoten_rahmen()); + let knoten_kreis : mod_vtm_helfer.schnittstelle_xmlknoten = ( + new mod_vtm_helfer.klasse_xmlknoten_normal + ( + "circle", + { + "cx": (0.0).toFixed(svg_float_praezission), + "cy": (0.0).toFixed(svg_float_praezission), + "r": (0.25).toFixed(svg_float_praezission), + "class": ( + [ + "kreis", + "positiv", + ].join(" ") + ), + } + ) + ); + kinder_feld.push(knoten_kreis); + break; + } + default: + { + let meldung : string = ("unbehandelter Aktor-Typ"); + throw (new Error(meldung)); + break; + } } let position : typ_position = position_von_stelle(this.stelle); let knoten_feld : mod_vtm_helfer.schnittstelle_xmlknoten = ( diff --git a/quelldatein/manifestation/svg/figur.ts b/quelldatein/manifestation/svg/figur.ts index 48e7c86..e403a2d 100644 --- a/quelldatein/manifestation/svg/figur.ts +++ b/quelldatein/manifestation/svg/figur.ts @@ -23,13 +23,13 @@ module mod_vtm_manifestation * @author kcf */ export class klasse_svg_figur - extends klasse_manifestation + extends klasse_manifestation { /** * @author kcf */ - public constructor(aufbau : mod_vtm_aufbau.klasse_figur) + public constructor(aufbau : mod_vtm_aufbau.typ_figur) { super(aufbau); } @@ -41,7 +41,7 @@ module mod_vtm_manifestation */ public darstellen() : mod_vtm_helfer.schnittstelle_xmlknoten { - let figur : mod_vtm_aufbau.klasse_figur = this.aufbau; + let figur : mod_vtm_aufbau.typ_figur = this.aufbau; let kinder_figur : Array = []; // Stein { @@ -61,7 +61,7 @@ module mod_vtm_manifestation } // Band { - let band : Array = figur.band_lesen(); + let band : Array = mod_vtm_aufbau.figur_band_lesen(figur); let kinder_band : Array = []; band.forEach ( @@ -109,7 +109,7 @@ module mod_vtm_manifestation ); kinder_figur.push(knoten_band); } - let position : typ_position = position_von_stelle(figur.stelle_lesen()); + let position : typ_position = position_von_stelle(mod_vtm_aufbau.figur_stelle_lesen(figur)); let knoten_figur = ( new mod_vtm_helfer.klasse_xmlknoten_normal ( diff --git a/quelldatein/manifestation/svg/partie.ts b/quelldatein/manifestation/svg/partie.ts index 4946c5d..e9d7ce3 100644 --- a/quelldatein/manifestation/svg/partie.ts +++ b/quelldatein/manifestation/svg/partie.ts @@ -23,13 +23,13 @@ module mod_vtm_manifestation * @author kcf */ export class klasse_svg_partie - extends klasse_manifestation + extends klasse_manifestation { /** * @author kcf */ - public constructor(aufbau : mod_vtm_aufbau.klasse_partie) + public constructor(aufbau : mod_vtm_aufbau.typ_partie) { super(aufbau); } @@ -48,11 +48,11 @@ module mod_vtm_manifestation // Felder { let kinder_felder : Array = []; - this.aufbau.welt_lesen().felder_lesen().forEach + mod_vtm_aufbau.welt_felder_lesen(mod_vtm_aufbau.partie_welt_lesen(this.aufbau)).forEach ( ({"stelle": stelle, "aktor": aktor}) => { - let manifestation_feld : klasse_manifestation = new klasse_svg_aktor(aktor, stelle); + let manifestation_feld : klasse_manifestation = new klasse_svg_aktor(aktor, stelle); let knoten_feld : mod_vtm_helfer.schnittstelle_xmlknoten = manifestation_feld.darstellen(); kinder_felder.push(knoten_feld); } @@ -85,11 +85,11 @@ module mod_vtm_manifestation } // Figur { - let figur_ : schnittstelle_fehlermonade = this.aufbau.figur_lesen(); + let figur_ : schnittstelle_fehlermonade = mod_vtm_aufbau.partie_figur_lesen(this.aufbau); if (figur_.ist_schlicht()) { - let figur : mod_vtm_aufbau.klasse_figur = figur_.lesen(); - let manifestation_figur : klasse_manifestation = (new klasse_svg_figur(figur)); + let figur : mod_vtm_aufbau.typ_figur = figur_.lesen(); + let manifestation_figur : klasse_manifestation = (new klasse_svg_figur(figur)); let knoten_figur : mod_vtm_helfer.schnittstelle_xmlknoten = manifestation_figur.darstellen(); kinder_partie.push(knoten_figur); } diff --git a/quelldatein/manifestation/web/partie.ts b/quelldatein/manifestation/web/partie.ts index 6f801f3..64872e2 100644 --- a/quelldatein/manifestation/web/partie.ts +++ b/quelldatein/manifestation/web/partie.ts @@ -33,7 +33,7 @@ module mod_vtm_manifestation * @author kcf */ export class klasse_web_partie - extends klasse_manifestation + extends klasse_manifestation { /** @@ -51,14 +51,15 @@ module mod_vtm_manifestation /** * @author kcf */ - public constructor(aufbau : mod_vtm_aufbau.klasse_partie, bereich : Element) + public constructor(aufbau : mod_vtm_aufbau.typ_partie, bereich : Element) { super(aufbau); this.bereich = bereich; this.intervall = (new klasse_nichts()); /* - this.aufbau.lauschen + mod_vtm_aufbau.partie_lauschen ( + this.aufbau, "aenderung_welt", (angaben) => { @@ -76,8 +77,9 @@ module mod_vtm_manifestation */ public einrichten() : void { - this.aufbau.lauschen + mod_vtm_aufbau.partie_lauschen ( + this.aufbau, "aenderung_aufgabe", (angaben) => { @@ -85,8 +87,9 @@ module mod_vtm_manifestation } ) ; - this.aufbau.lauschen + mod_vtm_aufbau.partie_lauschen ( + this.aufbau, "aenderung_welt", (angaben) => { @@ -94,8 +97,9 @@ module mod_vtm_manifestation } ) ; - this.aufbau.lauschen + mod_vtm_aufbau.partie_lauschen ( + this.aufbau, "aenderung_figur", (angaben) => { @@ -103,8 +107,9 @@ module mod_vtm_manifestation } ) ; - this.aufbau.lauschen + mod_vtm_aufbau.partie_lauschen ( + this.aufbau, "aenderung_modus", (angaben) => { @@ -123,7 +128,7 @@ module mod_vtm_manifestation */ private erneuern_aufgabe() : void { - document.querySelector("#aufgabe_text").innerHTML = text_nachbearbeiten(this.aufbau.aufgabe_lesen().text()); + document.querySelector("#aufgabe_text").innerHTML = text_nachbearbeiten(mod_vtm_aufbau.partie_aufgabe_lesen(this.aufbau).text()); } @@ -169,7 +174,7 @@ module mod_vtm_manifestation private erneuern_modus() : void { let status : string; - switch (this.aufbau.modus_lesen()) + switch (mod_vtm_aufbau.partie_modus_lesen(this.aufbau)) { case mod_vtm_aufbau.modus_initial: { @@ -207,7 +212,7 @@ module mod_vtm_manifestation */ public erneuern_knoepfe() : void { - let modus : mod_vtm_aufbau.typ_modus = this.aufbau.modus_lesen(); + let modus : mod_vtm_aufbau.typ_modus = mod_vtm_aufbau.partie_modus_lesen(this.aufbau); let klasse : string; switch (modus) { @@ -274,8 +279,8 @@ module mod_vtm_manifestation */ private fortfahren() : void { - this.aufbau.fortfahren(); - let modus : mod_vtm_aufbau.typ_modus = this.aufbau.modus_lesen(); + mod_vtm_aufbau.partie_fortfahren(this.aufbau); + let modus : mod_vtm_aufbau.typ_modus = mod_vtm_aufbau.partie_modus_lesen(this.aufbau); if (modus <= 1) { // nichts tun @@ -304,7 +309,7 @@ module mod_vtm_manifestation private bearbeiten() : void { this.anhalten(); - this.aufbau.zuruecksetzen(); + mod_vtm_aufbau.partie_zuruecksetzen(this.aufbau); } @@ -313,8 +318,8 @@ module mod_vtm_manifestation */ private leeren() : void { - this.aufbau.welt_leeren(); - this.aufbau.zuruecksetzen(); + mod_vtm_aufbau.partie_welt_leeren(this.aufbau); + mod_vtm_aufbau.partie_zuruecksetzen(this.aufbau); } @@ -350,7 +355,7 @@ module mod_vtm_manifestation let stelle_ : schnittstelle_fehlermonade = stelle_ermitteln(event.target); if (stelle_.ist_schlicht()) { - this.aufbau.welt_feld_wechseln(stelle_.lesen(), false); + mod_vtm_aufbau.partie_welt_feld_wechseln(this.aufbau, stelle_.lesen(), false); } else { @@ -369,7 +374,7 @@ module mod_vtm_manifestation let stelle_ : schnittstelle_fehlermonade = stelle_ermitteln(event.target); if (stelle_.ist_schlicht()) { - this.aufbau.welt_feld_wechseln(stelle_.lesen(), true); + mod_vtm_aufbau.partie_welt_feld_wechseln(this.aufbau, stelle_.lesen(), true); } else { @@ -389,7 +394,7 @@ module mod_vtm_manifestation if (stelle_.ist_schlicht()) { let inkrement : int = ((event["deltaY"] < 0) ? -1 : +1); - this.aufbau.welt_feld_drehen(stelle_.lesen(), inkrement); + mod_vtm_aufbau.partie_welt_feld_drehen(this.aufbau, stelle_.lesen(), inkrement); } else {