speicherung
This commit is contained in:
Christian Fraß
parent
9b530f4940
commit
dac259a252
55
hilfe.md
Normal file
55
hilfe.md
Normal file
|
|
@ -0,0 +1,55 @@
|
|||
Dieses Spiel ist inspiriert von [http://www.kongregate.com/games/PleasingFungus/manufactoria"](Manufacturia), [http://www.crazy-machines.com/](Crazy Machines), [http://worldofgoo.com/](World of Goo) … und auch von unvergessenen Stunden Hardware-Praktikum im Informatik-Studium :P
|
||||
|
||||
## Steuerung
|
||||
|
||||
- Links-Klick/Rechts-Klick: Feldtyp wechseln
|
||||
- Mausrad-Drehen: Feld drehen
|
||||
|
||||
## Figur
|
||||
|
||||
Die Figur kann durch Aktoren auf dem Spielplan umher bewegt werden und wird als schwarzer Kreis dargestellt.
|
||||
Zudem verfügt die Figur über ein Liste von gesetzen Symbolen (Band), dargestellt durch farbige Punkte neben der Figur. Gelesen wird das Band immer an der vordersten Stelle und geschrieben wird an die hinterste Stelle (FIFO-Prinzip).
|
||||
|
||||
## Aktoren
|
||||
Jedes Feld des Spielplans kann mit einem Aktor bestückt werden, der je nach Typ unterschiedliche Einflüsse auf die Figur ausübt. Folgende Typen stehen zur Verfügung:
|
||||
|
||||
### Eingang
|
||||
|
||||
Der Eingang ist fest platziert auf dem ganz linken Feld des Spielplans und wird durch ein weißes Dreieck dargestellt. An ihm wird die Spielfigur auf den Plan gesetzt und bewegt sich anschließend in die angezeigte Richtung.
|
||||
|
||||
### Ausgang
|
||||
|
||||
Auf dem ganz rechten Feld des Spielplans fest platziert befindet sich der Ausgang, der durch einen weißen Kreis dargestellt wird. Steuert man die Figur zu diesem Feld, so wird der aktuelle Band-Inhalt ausgelesen und akzeptiert.
|
||||
|
||||
### Abweiser
|
||||
|
||||
Jedes leere Feld beendet den Lauf der Figur mit einer Abweisung des aktuellen Band-Inhalts.
|
||||
|
||||
### Schieber
|
||||
|
||||
Dieser Aktor dient dazu die Figur von einem Feld zu einem benachbarten zu befördern ohne dabei den Band-Inhalt zu ändern.
|
||||
|
||||
### Schreiber
|
||||
|
||||
Um ein Symbol auf dem Band zu schreiben, wird dieser Aktor benötigt. Die jeweilige Farbe gibt an, welches Symbol geschrieben wird und die Richtung zeigt, wohin die Figur anschließend befördert wird.
|
||||
|
||||
### Weiche
|
||||
|
||||
An einer Weiche wird das erste Symbol auf dem Band der Figur gelesen und die übereinstimmende Richtung gewählt, zu welcher die Figur im Anschluss bewegt wird. Gibt es einen passenden Ausgang, so wird das gelesene Symbol vom Band entfernt. Falls kein Ausgang gefunden wird oder das Band leer ist, wird der Ersatz-Ausgang (grau) gewählt.
|
||||
|
||||
## Aufgaben
|
||||
|
||||
Ziel ist das Lösen von bestimmten Aufgaben. Dabei wird zwischen zwei Arten von Aufgaben unterschieden:
|
||||
|
||||
### Akzeptor
|
||||
|
||||
Hierbei geht es darum den Band-Inhalt der Figur zu untersuchen und zu entscheiden, ob er eine bestimmte Bedingung erfüllt oder nicht. Fall ja, so steuert man die Figur in den Ausgang; andernfalls auf ein beliebiges leeres Feld.
|
||||
|
||||
Beispiel: Genau dann akzeptieren, wenn das Band mindestens zwei mal rot enthält.
|
||||
|
||||
### Transduktor
|
||||
|
||||
Bei einer Transduktor-Aufgabe soll eine Ausgabe erzeugt werden, die in einer bestimmten Beziehung zur vorgefundenen Eingabe steht, also sozusagen eine Funktion angewendet werden.
|
||||
|
||||
Beispiel: Die Eingabe zwei mal wiederholt.
|
||||
|
||||
72
makefile
72
makefile
|
|
@ -25,17 +25,14 @@ ${dir_erzeugnis}/vtm.html: \
|
|||
${dir_quelldatein}/manifestation/web/vtm.html
|
||||
@ ${cmd_echo} "-- Struktur …"
|
||||
@ ${cmd_md} ${dir_erzeugnis}
|
||||
@ ${cmd_cp} ${dir_quelldatein}/manifestation/web/vtm.html ${dir_erzeugnis}/vtm.html
|
||||
@ ${cmd_cp} $^ $@
|
||||
|
||||
${dir_erzeugnis}/vtm.css: \
|
||||
${dir_quelldatein}/manifestation/web/vtm.scss \
|
||||
${dir_quelldatein}/manifestation/web/partie.scss
|
||||
@ ${cmd_echo} "-- Gestaltung …"
|
||||
@ ${cmd_md} ${dir_erzeugnis}
|
||||
@ ${cmd_cat} \
|
||||
${dir_quelldatein}/manifestation/web/vtm.scss \
|
||||
${dir_quelldatein}/manifestation/web/partie.scss \
|
||||
| ${cmd_sass} --stdin > ${dir_erzeugnis}/vtm.css
|
||||
@ ${cmd_cat} $^ | ${cmd_sass} --stdin > $@
|
||||
|
||||
${dir_erzeugnis}/vtm.dat.js: \
|
||||
${dir_quelldatein}/daten/aufgaben.dat.js \
|
||||
|
|
@ -43,23 +40,21 @@ ${dir_erzeugnis}/vtm.dat.js: \
|
|||
${dir_quelldatein}/daten/zeichenketten/en.dat.js
|
||||
@ ${cmd_echo} "-- Daten …"
|
||||
@ ${cmd_md} ${dir_erzeugnis}
|
||||
@ ${cmd_cat} \
|
||||
${dir_quelldatein}/daten/aufgaben.dat.js \
|
||||
${dir_quelldatein}/daten/zeichenketten/de.dat.js \
|
||||
${dir_quelldatein}/daten/zeichenketten/en.dat.js \
|
||||
> ${dir_erzeugnis}/vtm.dat.js
|
||||
@ ${cmd_cat} $^ > $@
|
||||
|
||||
${dir_erzeugnis}/vtm.js: \
|
||||
${dir_quelldatein}/basis/typen.ts \
|
||||
${dir_quelldatein}/basis/fehlermonade.ts \
|
||||
${dir_quelldatein}/basis/aufruf.ts \
|
||||
${dir_quelldatein}/helfer/typen.ts \
|
||||
${dir_quelldatein}/helfer/aufruf.ts \
|
||||
${dir_quelldatein}/helfer/fehlermonade/_fehlermonade.ts \
|
||||
${dir_quelldatein}/helfer/fehlermonade/nichts.ts \
|
||||
${dir_quelldatein}/helfer/fehlermonade/schlicht.ts \
|
||||
${dir_quelldatein}/helfer/xmlknoten/_xmlknoten.ts \
|
||||
${dir_quelldatein}/helfer/xmlknoten/text.ts \
|
||||
${dir_quelldatein}/helfer/xmlknoten/normal.ts \
|
||||
${dir_quelldatein}/helfer/verschiedenes.ts \
|
||||
${dir_quelldatein}/helfer/mathematik.ts \
|
||||
${dir_quelldatein}/helfer/vektor.ts \
|
||||
${dir_quelldatein}/helfer/hashmap.ts \
|
||||
${dir_quelldatein}/helfer/xmlknoten/_xmlknoten.ts \
|
||||
${dir_quelldatein}/helfer/xmlknoten/text.ts \
|
||||
${dir_quelldatein}/helfer/xmlknoten/normal.ts \
|
||||
${dir_quelldatein}/helfer/uebersetzung.ts \
|
||||
${dir_quelldatein}/daten.ts \
|
||||
${dir_quelldatein}/aufbau/richtung.ts \
|
||||
|
|
@ -94,48 +89,5 @@ ${dir_erzeugnis}/vtm.js: \
|
|||
${dir_quelldatein}/haupt.ts
|
||||
@ ${cmd_echo} "-- Logik …"
|
||||
@ ${cmd_md} ${dir_erzeugnis}
|
||||
@ ${cmd_tsc} \
|
||||
${dir_quelldatein}/basis/typen.ts \
|
||||
${dir_quelldatein}/basis/fehlermonade.ts \
|
||||
${dir_quelldatein}/basis/aufruf.ts \
|
||||
${dir_quelldatein}/helfer/verschiedenes.ts \
|
||||
${dir_quelldatein}/helfer/mathematik.ts \
|
||||
${dir_quelldatein}/helfer/vektor.ts \
|
||||
${dir_quelldatein}/helfer/hashmap.ts \
|
||||
${dir_quelldatein}/helfer/xmlknoten/_xmlknoten.ts \
|
||||
${dir_quelldatein}/helfer/xmlknoten/text.ts \
|
||||
${dir_quelldatein}/helfer/xmlknoten/normal.ts \
|
||||
${dir_quelldatein}/helfer/uebersetzung.ts \
|
||||
${dir_quelldatein}/daten.ts \
|
||||
${dir_quelldatein}/aufbau/richtung.ts \
|
||||
${dir_quelldatein}/aufbau/symbol.ts \
|
||||
${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/welt.ts \
|
||||
${dir_quelldatein}/aufbau/aufgaben/test.ts \
|
||||
${dir_quelldatein}/aufbau/aufgaben/akzeptortest.ts \
|
||||
${dir_quelldatein}/aufbau/aufgaben/transduktortest.ts \
|
||||
${dir_quelldatein}/aufbau/aufgaben/akzeptoraufgabe.ts \
|
||||
${dir_quelldatein}/aufbau/aufgaben/transduktoraufgabe.ts \
|
||||
${dir_quelldatein}/aufbau/aufgaben/aufgabe.ts \
|
||||
${dir_quelldatein}/aufbau/modus.ts \
|
||||
${dir_quelldatein}/aufbau/partie.ts \
|
||||
${dir_quelldatein}/manifestation/manifestation.ts \
|
||||
${dir_quelldatein}/manifestation/position.ts \
|
||||
${dir_quelldatein}/manifestation/svg/svg.ts \
|
||||
${dir_quelldatein}/manifestation/svg/figur.ts \
|
||||
${dir_quelldatein}/manifestation/svg/aktor.ts \
|
||||
${dir_quelldatein}/manifestation/svg/partie.ts \
|
||||
${dir_quelldatein}/manifestation/web/partie.ts \
|
||||
${dir_quelldatein}/manifestation/speicher/partie.ts \
|
||||
${dir_quelldatein}/haupt.ts \
|
||||
--outFile ${dir_erzeugnis}/vtm.js
|
||||
@ ${cmd_tsc} $^ --outFile $@
|
||||
|
||||
|
|
|
|||
|
|
@ -152,11 +152,11 @@ module mod_vtm
|
|||
)
|
||||
: void
|
||||
{
|
||||
let symbol_ : schnittstelle_fehlermonade<mod_symbol.typ_symbol> = mod_figur.lesen(figur);
|
||||
let symbol_ : lib_fehlermonade.typ_fehlermonade<mod_symbol.typ_symbol> = mod_figur.lesen(figur);
|
||||
let summand : mod_richtung.typ_richtung;
|
||||
if (symbol_.ist_schlicht())
|
||||
if (lib_fehlermonade.voll(symbol_))
|
||||
{
|
||||
let symbol : mod_symbol.typ_symbol = symbol_.lesen();
|
||||
let symbol : mod_symbol.typ_symbol = lib_fehlermonade.lesen(symbol_);
|
||||
if (symbol === leser.symbol_links)
|
||||
{
|
||||
mod_figur.schieben(figur);
|
||||
|
|
|
|||
|
|
@ -130,15 +130,15 @@ module mod_vtm
|
|||
(
|
||||
figur : typ_figur
|
||||
)
|
||||
: schnittstelle_fehlermonade<mod_symbol.typ_symbol>
|
||||
: lib_fehlermonade.typ_fehlermonade<mod_symbol.typ_symbol>
|
||||
{
|
||||
if (figur.band.length <= 0)
|
||||
{
|
||||
return (new klasse_nichts<mod_symbol.typ_symbol>());
|
||||
return (lib_fehlermonade.mod_nichts.erstellen<mod_symbol.typ_symbol>());
|
||||
}
|
||||
else
|
||||
{
|
||||
return (new klasse_schlicht<mod_symbol.typ_symbol>(figur.band[0]));
|
||||
return (lib_fehlermonade.mod_schlicht.erstellen<mod_symbol.typ_symbol>(figur.band[0]));
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -31,9 +31,9 @@ module mod_vtm
|
|||
export type typ_partie =
|
||||
{
|
||||
welt : mod_welt.typ_welt;
|
||||
figur : schnittstelle_fehlermonade<mod_figur.typ_figur>;
|
||||
figur : lib_fehlermonade.typ_fehlermonade<mod_figur.typ_figur>;
|
||||
aufgabe : mod_aufgabe.typ_aufgabe;
|
||||
testindex : schnittstelle_fehlermonade<int>;
|
||||
testindex : lib_fehlermonade.typ_fehlermonade<int>;
|
||||
modus : mod_modus.typ_modus;
|
||||
lauscher : {[ereignis : string] : Array<(angaben ?: any)=>void>};
|
||||
}
|
||||
|
|
@ -115,8 +115,8 @@ module mod_vtm
|
|||
*/
|
||||
export function zuruecksetzen(partie : typ_partie, bescheid_geben : boolean = true) : void
|
||||
{
|
||||
partie.figur = (new klasse_nichts<mod_figur.typ_figur>());
|
||||
partie.testindex = (new klasse_nichts<int>());
|
||||
partie.figur = (lib_fehlermonade.mod_nichts.erstellen<mod_figur.typ_figur>());
|
||||
partie.testindex = (lib_fehlermonade.mod_nichts.erstellen<int>());
|
||||
partie.modus = mod_modus.initial;
|
||||
if (bescheid_geben)
|
||||
{
|
||||
|
|
@ -197,7 +197,7 @@ module mod_vtm
|
|||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export function figur_lesen(partie : typ_partie) : schnittstelle_fehlermonade<mod_figur.typ_figur>
|
||||
export function figur_lesen(partie : typ_partie) : lib_fehlermonade.typ_fehlermonade<mod_figur.typ_figur>
|
||||
{
|
||||
return partie.figur;
|
||||
}
|
||||
|
|
@ -270,19 +270,19 @@ module mod_vtm
|
|||
case mod_modus.initial:
|
||||
{
|
||||
partie.modus = mod_modus.ungewiss;
|
||||
partie.testindex = (new klasse_schlicht<int>(0));
|
||||
partie.testindex = (lib_fehlermonade.mod_schlicht.erstellen<int>(0));
|
||||
benachrichtigen(partie, "aenderung_modus", {});
|
||||
break;
|
||||
}
|
||||
case mod_modus.ungewiss:
|
||||
{
|
||||
if (! partie.figur.ist_schlicht())
|
||||
if (! lib_fehlermonade.voll(partie.figur))
|
||||
{
|
||||
let test : mod_test.typ_test = mod_aufgabe.tests(partie.aufgabe)[partie.testindex.lesen()];
|
||||
let test : mod_test.typ_test = mod_aufgabe.tests(partie.aufgabe)[lib_fehlermonade.lesen(partie.testindex)];
|
||||
let band : Array<mod_symbol.typ_symbol> = mod_vtm.mod_helfer.liste_kopieren<mod_symbol.typ_symbol>(mod_test.eingabe(test));
|
||||
let stelle : mod_stelle.typ_stelle = mod_welt.erzeuger_finden(partie.welt);
|
||||
partie.figur = (
|
||||
new klasse_schlicht<mod_figur.typ_figur>
|
||||
lib_fehlermonade.mod_schlicht.erstellen<mod_figur.typ_figur>
|
||||
(
|
||||
mod_figur.erstellen
|
||||
(
|
||||
|
|
@ -294,10 +294,14 @@ module mod_vtm
|
|||
}
|
||||
else
|
||||
{
|
||||
let figur : mod_figur.typ_figur = partie.figur.lesen();
|
||||
let figur : mod_figur.typ_figur = lib_fehlermonade.lesen(partie.figur);
|
||||
let stelle : mod_stelle.typ_stelle = mod_figur.stelle_lesen(figur);
|
||||
let aktor_ : schnittstelle_fehlermonade<mod_aktor.typ_aktor> = mod_welt.feld_holen(partie.welt, stelle);
|
||||
let aktor : mod_aktor.typ_aktor = (aktor_.ist_schlicht() ? aktor_.lesen() : mod_aktor_verwerfer.erstellen_aktor());
|
||||
let aktor_ : lib_fehlermonade.typ_fehlermonade<mod_aktor.typ_aktor> = mod_welt.feld_holen(partie.welt, stelle);
|
||||
let aktor : mod_aktor.typ_aktor = (
|
||||
lib_fehlermonade.voll(aktor_)
|
||||
? lib_fehlermonade.lesen(aktor_)
|
||||
: mod_aktor_verwerfer.erstellen_aktor()
|
||||
);
|
||||
mod_aktor.verwenden(aktor, figur);
|
||||
let zustand : mod_zustand.typ_zustand = mod_figur.zustand_lesen(figur);
|
||||
if (zustand === mod_zustand.laufend)
|
||||
|
|
@ -308,8 +312,8 @@ module mod_vtm
|
|||
{
|
||||
let angenommen : boolean = (zustand === mod_zustand.angenommen);
|
||||
let ausgabe : Array<mod_symbol.typ_symbol> = mod_figur.band_lesen(figur);
|
||||
partie.figur = (new klasse_nichts<mod_figur.typ_figur>());
|
||||
let testindex : int = partie.testindex.lesen();
|
||||
partie.figur = (lib_fehlermonade.mod_nichts.erstellen<mod_figur.typ_figur>());
|
||||
let testindex : int = lib_fehlermonade.lesen(partie.testindex);
|
||||
let tests : Array<mod_test.typ_test> = mod_aufgabe.tests(partie.aufgabe);
|
||||
let test : mod_test.typ_test = tests[testindex];
|
||||
if (! mod_test.pruefen(test, angenommen, ausgabe))
|
||||
|
|
@ -323,12 +327,12 @@ module mod_vtm
|
|||
if (testindex < tests.length)
|
||||
{
|
||||
// nächsten Test auswählen
|
||||
partie.testindex = (new klasse_schlicht<int>(testindex));
|
||||
partie.testindex = (lib_fehlermonade.mod_schlicht.erstellen<int>(testindex));
|
||||
}
|
||||
else
|
||||
{
|
||||
// auf Modus "korrekt" wechseln
|
||||
partie.testindex = (new klasse_nichts<int>());
|
||||
partie.testindex = (lib_fehlermonade.mod_nichts.erstellen<int>());
|
||||
partie.modus = mod_modus.korrekt;
|
||||
benachrichtigen(partie, "aenderung_modus", {});
|
||||
}
|
||||
|
|
|
|||
|
|
@ -30,7 +30,7 @@ module mod_vtm
|
|||
*/
|
||||
export type typ_welt =
|
||||
{
|
||||
felder : mod_vtm_helfer.klasse_hashmap<mod_stelle.typ_stelle, mod_aktor.typ_aktor>;
|
||||
felder : mod_vtm.mod_helfer.mod_hashmap.typ_hashmap<mod_stelle.typ_stelle, mod_aktor.typ_aktor>;
|
||||
}
|
||||
;
|
||||
|
||||
|
|
@ -40,7 +40,7 @@ module mod_vtm
|
|||
*/
|
||||
export function erstellen
|
||||
(
|
||||
felder : mod_vtm_helfer.klasse_hashmap<mod_stelle.typ_stelle, mod_aktor.typ_aktor> = (new mod_vtm_helfer.klasse_hashmap<mod_stelle.typ_stelle, mod_aktor.typ_aktor>(mod_stelle.hash))
|
||||
felder : mod_vtm.mod_helfer.mod_hashmap.typ_hashmap<mod_stelle.typ_stelle, mod_aktor.typ_aktor> = mod_vtm.mod_helfer.mod_hashmap.erstellen<mod_stelle.typ_stelle, mod_aktor.typ_aktor>(mod_stelle.hash)
|
||||
)
|
||||
: typ_welt
|
||||
{
|
||||
|
|
@ -56,8 +56,9 @@ module mod_vtm
|
|||
export function felder_lesen(welt : typ_welt) : Array<{stelle : mod_stelle.typ_stelle; aktor : mod_aktor.typ_aktor;}>
|
||||
{
|
||||
let felder : Array<{stelle : mod_stelle.typ_stelle; aktor : mod_aktor.typ_aktor;}> = [];
|
||||
welt.felder.iterieren
|
||||
mod_vtm.mod_helfer.mod_hashmap.iterieren
|
||||
(
|
||||
welt.felder,
|
||||
(stelle, aktor) => felder.push({"stelle": stelle, "aktor": aktor})
|
||||
)
|
||||
;
|
||||
|
|
@ -68,9 +69,9 @@ module mod_vtm
|
|||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export function feld_holen(welt : typ_welt, stelle : mod_stelle.typ_stelle) : schnittstelle_fehlermonade<mod_aktor.typ_aktor>
|
||||
export function feld_holen(welt : typ_welt, stelle : mod_stelle.typ_stelle) : lib_fehlermonade.typ_fehlermonade<mod_aktor.typ_aktor>
|
||||
{
|
||||
return welt.felder.holen(stelle);
|
||||
return mod_vtm.mod_helfer.mod_hashmap.holen(welt.felder, stelle);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -79,7 +80,7 @@ module mod_vtm
|
|||
*/
|
||||
export function feld_setzen(welt : typ_welt, stelle : mod_stelle.typ_stelle, aktor : mod_aktor.typ_aktor) : void
|
||||
{
|
||||
welt.felder.setzen(stelle, aktor);
|
||||
mod_vtm.mod_helfer.mod_hashmap.setzen(welt.felder, stelle, aktor);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -165,11 +166,11 @@ module mod_vtm
|
|||
]
|
||||
)
|
||||
);
|
||||
let index_alt : schnittstelle_fehlermonade<int>;
|
||||
let aktor_alt_ : schnittstelle_fehlermonade<mod_aktor.typ_aktor> = welt.felder.holen(stelle);
|
||||
if (aktor_alt_.ist_schlicht())
|
||||
let index_alt : lib_fehlermonade.typ_fehlermonade<int>;
|
||||
let aktor_alt_ : lib_fehlermonade.typ_fehlermonade<mod_aktor.typ_aktor> = mod_vtm.mod_helfer.mod_hashmap.holen(welt.felder, stelle);
|
||||
if (lib_fehlermonade.voll(aktor_alt_))
|
||||
{
|
||||
let aktor_alt : mod_aktor.typ_aktor = aktor_alt_.lesen();
|
||||
let aktor_alt : mod_aktor.typ_aktor = lib_fehlermonade.lesen(aktor_alt_);
|
||||
let gefunden : boolean = (
|
||||
liste.some
|
||||
(
|
||||
|
|
@ -177,7 +178,7 @@ module mod_vtm
|
|||
{
|
||||
if (eintrag.pruefer(aktor_alt))
|
||||
{
|
||||
index_alt = (new klasse_schlicht<int>(index));
|
||||
index_alt = (lib_fehlermonade.mod_schlicht.erstellen<int>(index));
|
||||
return true;
|
||||
}
|
||||
else
|
||||
|
|
@ -189,7 +190,7 @@ module mod_vtm
|
|||
);
|
||||
if (! gefunden)
|
||||
{
|
||||
index_alt = (new klasse_nichts<int>());
|
||||
index_alt = (lib_fehlermonade.mod_nichts.erstellen<int>());
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -200,11 +201,11 @@ module mod_vtm
|
|||
{
|
||||
let meldung : string = "kein Aktor gesetzt";
|
||||
// console.warn(meldung);
|
||||
index_alt = (new klasse_schlicht<int>(0));
|
||||
index_alt = (lib_fehlermonade.mod_schlicht.erstellen<int>(0));
|
||||
}
|
||||
if (index_alt.ist_schlicht())
|
||||
if (lib_fehlermonade.voll(index_alt))
|
||||
{
|
||||
let index_neu : int = mod_vtm.mod_helfer.mod_mathematik.mod(index_alt.lesen() + (umgekehrt ? -1 : +1), liste.length);
|
||||
let index_neu : int = mod_vtm.mod_helfer.mod_mathematik.mod(lib_fehlermonade.lesen(index_alt) + (umgekehrt ? -1 : +1), liste.length);
|
||||
let aktor_neu : mod_aktor.typ_aktor = liste[index_neu].ersteller();
|
||||
feld_setzen(welt, stelle, aktor_neu);
|
||||
}
|
||||
|
|
@ -222,10 +223,10 @@ module mod_vtm
|
|||
*/
|
||||
export function feld_drehen(welt : typ_welt, stelle : mod_stelle.typ_stelle, inkrement : int = +1) : void
|
||||
{
|
||||
let aktor_ : schnittstelle_fehlermonade<mod_aktor.typ_aktor> = welt.felder.holen(stelle);
|
||||
if (aktor_.ist_schlicht)
|
||||
let aktor_ : lib_fehlermonade.typ_fehlermonade<mod_aktor.typ_aktor> = mod_vtm.mod_helfer.mod_hashmap.holen(welt.felder, stelle);
|
||||
if (lib_fehlermonade.voll(aktor_))
|
||||
{
|
||||
mod_aktor.drehen(aktor_.lesen(), inkrement);
|
||||
mod_aktor.drehen(lib_fehlermonade.lesen(aktor_), inkrement);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -240,29 +241,30 @@ module mod_vtm
|
|||
*/
|
||||
export function erzeuger_finden(welt : typ_welt) : mod_stelle.typ_stelle
|
||||
{
|
||||
let stelle : schnittstelle_fehlermonade<mod_stelle.typ_stelle> = (new klasse_nichts<mod_stelle.typ_stelle>());
|
||||
welt.felder.iterieren
|
||||
let stelle : lib_fehlermonade.typ_fehlermonade<mod_stelle.typ_stelle> = (lib_fehlermonade.mod_nichts.erstellen<mod_stelle.typ_stelle>());
|
||||
mod_vtm.mod_helfer.mod_hashmap.iterieren
|
||||
(
|
||||
welt.felder,
|
||||
(stelle_, aktor) =>
|
||||
{
|
||||
if (aktor.art === "erzeuger")
|
||||
{
|
||||
if (stelle.ist_schlicht())
|
||||
if (lib_fehlermonade.voll(stelle))
|
||||
{
|
||||
let meldung : string = "mehrere Erzeuger gefunden";
|
||||
throw (new Error(meldung));
|
||||
}
|
||||
else
|
||||
{
|
||||
stelle = (new klasse_schlicht<mod_stelle.typ_stelle>(stelle_));
|
||||
stelle = (lib_fehlermonade.mod_schlicht.erstellen<mod_stelle.typ_stelle>(stelle_));
|
||||
}
|
||||
}
|
||||
}
|
||||
)
|
||||
;
|
||||
if (stelle.ist_schlicht())
|
||||
if (lib_fehlermonade.voll(stelle))
|
||||
{
|
||||
return stelle.lesen();
|
||||
return lib_fehlermonade.lesen(stelle);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -298,7 +300,7 @@ module mod_vtm
|
|||
{
|
||||
aktor = mod_aktor_verwerfer.erstellen_aktor();
|
||||
}
|
||||
welt.felder.setzen(stelle, aktor);
|
||||
mod_vtm.mod_helfer.mod_hashmap.setzen(welt.felder, stelle, aktor);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -313,8 +315,9 @@ module mod_vtm
|
|||
{
|
||||
let roh : any = {};
|
||||
roh["felder"] = {};
|
||||
welt.felder.iterieren
|
||||
mod_vtm.mod_helfer.mod_hashmap.iterieren
|
||||
(
|
||||
welt.felder,
|
||||
(stelle, aktor) =>
|
||||
{
|
||||
let stelle_ : string = mod_stelle.exportieren(stelle);
|
||||
|
|
@ -332,13 +335,13 @@ module mod_vtm
|
|||
*/
|
||||
export function importieren(roh : any) : typ_welt
|
||||
{
|
||||
let felder : mod_vtm_helfer.klasse_hashmap<mod_stelle.typ_stelle, mod_aktor.typ_aktor> = (new mod_vtm_helfer.klasse_hashmap<mod_stelle.typ_stelle, mod_aktor.typ_aktor>(mod_stelle.hash));
|
||||
let felder : mod_vtm.mod_helfer.mod_hashmap.typ_hashmap<mod_stelle.typ_stelle, mod_aktor.typ_aktor> = (mod_vtm.mod_helfer.mod_hashmap.erstellen<mod_stelle.typ_stelle, mod_aktor.typ_aktor>(mod_stelle.hash));
|
||||
for (let stelle_ in roh["felder"])
|
||||
{
|
||||
let stelle : mod_stelle.typ_stelle = mod_stelle.importieren(stelle_);
|
||||
let aktor_ : mod_aktor.typ_aktor = roh["felder"][stelle_];
|
||||
let aktor : mod_aktor.typ_aktor = mod_aktor.importieren(aktor_);
|
||||
felder.setzen(stelle, aktor);
|
||||
mod_vtm.mod_helfer.mod_hashmap.setzen(felder, stelle, aktor);
|
||||
}
|
||||
return (
|
||||
erstellen
|
||||
|
|
|
|||
|
|
@ -37,15 +37,15 @@ module mod_vtm_daten
|
|||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export function lesen(schluessel : string) : schnittstelle_fehlermonade<any>
|
||||
export function lesen(schluessel : string) : lib_fehlermonade.typ_fehlermonade<any>
|
||||
{
|
||||
if (schluessel in _speicher)
|
||||
{
|
||||
return (new klasse_schlicht<any>(_speicher[schluessel]));
|
||||
return (lib_fehlermonade.mod_schlicht.erstellen<any>(_speicher[schluessel]));
|
||||
}
|
||||
else
|
||||
{
|
||||
return (new klasse_nichts<any>());
|
||||
return (lib_fehlermonade.mod_nichts.erstellen<any>());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -24,10 +24,10 @@ module mod_vtm
|
|||
*/
|
||||
function aufgaben_eintragen(behandler : (aufgabe : mod_aufbau.mod_aufgabe.typ_aufgabe)=>void) : void
|
||||
{
|
||||
let aufgaben_roh_ : schnittstelle_fehlermonade<Array<any>> = mod_vtm_daten.lesen("aufgaben");
|
||||
if (aufgaben_roh_.ist_schlicht())
|
||||
let aufgaben_roh_ : lib_fehlermonade.typ_fehlermonade<Array<any>> = mod_vtm_daten.lesen("aufgaben");
|
||||
if (lib_fehlermonade.voll(aufgaben_roh_))
|
||||
{
|
||||
let aufgaben_roh : Array<any> = aufgaben_roh_.lesen();
|
||||
let aufgaben_roh : Array<any> = lib_fehlermonade.lesen(aufgaben_roh_);
|
||||
let dom_auswahl : Element = document.querySelector("#aufgabe_auswahl");
|
||||
aufgaben_roh.forEach
|
||||
(
|
||||
|
|
@ -153,7 +153,7 @@ module mod_vtm
|
|||
mod_aufbau.mod_stelle.null_()
|
||||
)
|
||||
);
|
||||
let xmlknoten : mod_vtm_helfer.typ_xmlknoten = (
|
||||
let xmlknoten : mod_vtm.mod_helfer.mod_xml.typ_knoten = (
|
||||
mod_manifestation.mod_svg.wurzel
|
||||
(
|
||||
von_x, von_y,
|
||||
|
|
@ -162,7 +162,7 @@ module mod_vtm
|
|||
[mod_manifestation.darstellen(manifestation)]
|
||||
)
|
||||
);
|
||||
eintrag.bereich.querySelector(".hilfe_aktoren_aktor_bild").innerHTML = mod_vtm_helfer.xmlknoten_darstellen(xmlknoten);
|
||||
eintrag.bereich.querySelector(".hilfe_aktoren_aktor_bild").innerHTML = mod_vtm.mod_helfer.mod_xml.darstellen(xmlknoten);
|
||||
}
|
||||
)
|
||||
;
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ function fallunterscheidung<typ_ergebnis>
|
|||
(
|
||||
komplex : typ_komplex<any>,
|
||||
faelle : {[art : string] : (angaben ?: any)=>typ_ergebnis},
|
||||
ersatz : schnittstelle_fehlermonade<(komplex : typ_komplex<any>)=>typ_ergebnis> = (new klasse_nichts<(komplex : typ_komplex<any>)=>typ_ergebnis>())
|
||||
ersatz : (komplex : typ_komplex<any>)=>typ_ergebnis = ((komplex) => {throw (new Error("unbehandelt"));})
|
||||
)
|
||||
: typ_ergebnis
|
||||
{
|
||||
|
|
@ -61,16 +61,60 @@ function fallunterscheidung<typ_ergebnis>
|
|||
{
|
||||
let meldung : string = ("unbehandelte Art '" + komplex.art + "'");
|
||||
console.warn(meldung);
|
||||
if (ersatz.ist_schlicht())
|
||||
{
|
||||
let ergebnis : typ_ergebnis = ersatz.lesen()(komplex);
|
||||
return ergebnis;
|
||||
}
|
||||
else
|
||||
{
|
||||
throw (new Error("unbehandelt"));
|
||||
}
|
||||
let ergebnis : typ_ergebnis = ersatz(komplex);
|
||||
return ergebnis;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
module lib_brauch
|
||||
{
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export type typ_brauch<typ_signatur> = {[domäne : string] : typ_signatur};
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export function erstellen<typ_signatur>
|
||||
(
|
||||
)
|
||||
: typ_brauch<typ_signatur>
|
||||
{
|
||||
return {};
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export function umsetzen<typ_signatur>
|
||||
(
|
||||
brauch : typ_brauch<typ_signatur>,
|
||||
domäne : string,
|
||||
implementierung : typ_signatur
|
||||
)
|
||||
: void
|
||||
{
|
||||
brauch[domäne] = implementierung;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export function anwenden<typ_signatur>
|
||||
(
|
||||
brauch : typ_brauch<typ_signatur>,
|
||||
domäne : string
|
||||
)
|
||||
: typ_signatur
|
||||
{
|
||||
return brauch[domäne];
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -16,100 +16,47 @@
|
|||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
interface schnittstelle_fehlermonade<typ_wert>
|
||||
module lib_fehlermonade
|
||||
{
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
ist_schlicht() : boolean;
|
||||
export type typ_fehlermonade<typ_wert> = typ_komplex<typ_wert>;
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
lesen() : typ_wert;
|
||||
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
class klasse_nichts<typ_wert>
|
||||
implements schnittstelle_fehlermonade<typ_wert>
|
||||
{
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
public constructor()
|
||||
export type signatur_fehlermonade<typ_wert> =
|
||||
{
|
||||
voll : (fehlermonade : typ_fehlermonade<typ_wert>)=>boolean;
|
||||
lesen : (fehlermonade : typ_fehlermonade<typ_wert>)=>typ_wert;
|
||||
}
|
||||
;
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export var brauch_fehlermonade : lib_brauch.typ_brauch<signatur_fehlermonade<any>> = lib_brauch.erstellen<signatur_fehlermonade<any>>();
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export function voll<typ_wert>(fehlermonade : typ_fehlermonade<typ_wert>) : boolean
|
||||
{
|
||||
return lib_brauch.anwenden(brauch_fehlermonade, fehlermonade.art)["voll"](fehlermonade);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
public ist_schlicht() : boolean
|
||||
export function lesen<typ_wert>(fehlermonade : typ_fehlermonade<typ_wert>) : typ_wert
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
public lesen() : typ_wert
|
||||
{
|
||||
let meldung : string = "ist nichts";
|
||||
throw (new Error(meldung));
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
class klasse_schlicht<typ_wert>
|
||||
implements schnittstelle_fehlermonade<typ_wert>
|
||||
{
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
private wert : typ_wert;
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
public constructor(wert : typ_wert)
|
||||
{
|
||||
this.wert = wert;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
public ist_schlicht() : boolean
|
||||
{
|
||||
return true;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
public lesen() : typ_wert
|
||||
{
|
||||
return this.wert;
|
||||
return lib_brauch.anwenden(brauch_fehlermonade, fehlermonade.art)["lesen"](fehlermonade);
|
||||
}
|
||||
|
||||
}
|
||||
51
quelldatein/helfer/fehlermonade/nichts.ts
Normal file
51
quelldatein/helfer/fehlermonade/nichts.ts
Normal file
|
|
@ -0,0 +1,51 @@
|
|||
/*
|
||||
* Verrückte Turing-Maschinen — A turing complete game
|
||||
* Copyright (C) 2016 Christian Fraß <vidofnir@folksprak.org>
|
||||
*
|
||||
* 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 <https://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
module lib_fehlermonade
|
||||
{
|
||||
|
||||
export module mod_nichts
|
||||
{
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export function erstellen<typ_wert>() : typ_fehlermonade<typ_wert>
|
||||
{
|
||||
return einpacken<any>("nichts", {});
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
lib_brauch.umsetzen<signatur_fehlermonade<any>>
|
||||
(
|
||||
brauch_fehlermonade,
|
||||
"nichts",
|
||||
{
|
||||
"voll": (fehlermonade) => false,
|
||||
"lesen": (fehlermonade) => {throw (new Error("lesen von nichts"));},
|
||||
}
|
||||
)
|
||||
;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
51
quelldatein/helfer/fehlermonade/schlicht.ts
Normal file
51
quelldatein/helfer/fehlermonade/schlicht.ts
Normal file
|
|
@ -0,0 +1,51 @@
|
|||
/*
|
||||
* Verrückte Turing-Maschinen — A turing complete game
|
||||
* Copyright (C) 2016 Christian Fraß <vidofnir@folksprak.org>
|
||||
*
|
||||
* 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 <https://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
module lib_fehlermonade
|
||||
{
|
||||
|
||||
export module mod_schlicht
|
||||
{
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export function erstellen<typ_wert>(wert : typ_wert) : typ_fehlermonade<typ_wert>
|
||||
{
|
||||
return einpacken<any>("schlicht", {"wert": wert});
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
lib_brauch.umsetzen<signatur_fehlermonade<any>>
|
||||
(
|
||||
brauch_fehlermonade,
|
||||
"schlicht",
|
||||
{
|
||||
"voll": (fehlermonade) => true,
|
||||
"lesen": (fehlermonade) => auspacken<any>(fehlermonade).wert,
|
||||
}
|
||||
)
|
||||
;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
@ -16,82 +16,104 @@
|
|||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
module mod_vtm_helfer
|
||||
module mod_vtm
|
||||
{
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export class klasse_hashmap<typ_schluessel, typ_wert>
|
||||
export module mod_helfer
|
||||
{
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
private hashfunction : (schluessel : typ_schluessel)=>string;
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
private speicher : {[hashwert : string] : {schluessel : typ_schluessel; wert : typ_wert;}};
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
public constructor(hashfunction : (schluessel : typ_schluessel)=>string)
|
||||
export module mod_hashmap
|
||||
{
|
||||
this.hashfunction = hashfunction;
|
||||
this.speicher = {};
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
public setzen(schluessel : typ_schluessel, wert : typ_wert) : void
|
||||
{
|
||||
let hashwert : string = this.hashfunction(schluessel);
|
||||
this.speicher[hashwert] = {"schluessel": schluessel, "wert": wert};
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
public holen(schluessel : typ_schluessel) : schnittstelle_fehlermonade<typ_wert>
|
||||
{
|
||||
let hashwert : string = this.hashfunction(schluessel);
|
||||
if (hashwert in this.speicher)
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export type typ_hashmap<typ_schluessel, typ_wert> =
|
||||
{
|
||||
let wert : typ_wert = this.speicher[hashwert].wert;
|
||||
return (new klasse_schlicht<typ_wert>(wert));
|
||||
hashfunction : (schluessel : typ_schluessel)=>string;
|
||||
speicher : {[hashwert : string] : {schluessel : typ_schluessel; wert : typ_wert;}};
|
||||
}
|
||||
else
|
||||
{
|
||||
return (new klasse_nichts<typ_wert>());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
public iterieren(prozedur : (schluessel ?: typ_schluessel, wert ?: typ_wert)=>void) : void
|
||||
{
|
||||
Object.keys(this.speicher).forEach
|
||||
(
|
||||
(hashwert) =>
|
||||
{
|
||||
let paar : {schluessel : typ_schluessel; wert : typ_wert;} = this.speicher[hashwert];
|
||||
prozedur(paar.schluessel, paar.wert);
|
||||
}
|
||||
)
|
||||
;
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export function erstellen<typ_schluessel, typ_wert>
|
||||
(
|
||||
hashfunction : (schluessel : typ_schluessel)=>string
|
||||
)
|
||||
: typ_hashmap<typ_schluessel, typ_wert>
|
||||
{
|
||||
return {
|
||||
"hashfunction": hashfunction,
|
||||
"speicher": {},
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export function setzen<typ_schluessel, typ_wert>
|
||||
(
|
||||
hashmap : typ_hashmap<typ_schluessel, typ_wert>,
|
||||
schluessel : typ_schluessel,
|
||||
wert : typ_wert
|
||||
)
|
||||
: void
|
||||
{
|
||||
let hashwert : string = hashmap.hashfunction(schluessel);
|
||||
hashmap.speicher[hashwert] = {"schluessel": schluessel, "wert": wert};
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export function holen<typ_schluessel, typ_wert>
|
||||
(
|
||||
hashmap : typ_hashmap<typ_schluessel, typ_wert>,
|
||||
schluessel : typ_schluessel
|
||||
)
|
||||
: lib_fehlermonade.typ_fehlermonade<typ_wert>
|
||||
{
|
||||
let hashwert : string = hashmap.hashfunction(schluessel);
|
||||
if (hashwert in hashmap.speicher)
|
||||
{
|
||||
let wert : typ_wert = hashmap.speicher[hashwert].wert;
|
||||
return (lib_fehlermonade.mod_schlicht.erstellen<typ_wert>(wert));
|
||||
}
|
||||
else
|
||||
{
|
||||
return (lib_fehlermonade.mod_nichts.erstellen<typ_wert>());
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export function iterieren<typ_schluessel, typ_wert>
|
||||
(
|
||||
hashmap : typ_hashmap<typ_schluessel, typ_wert>,
|
||||
prozedur : (schluessel ?: typ_schluessel, wert ?: typ_wert)=>void
|
||||
)
|
||||
: void
|
||||
{
|
||||
Object.keys(hashmap.speicher).forEach
|
||||
(
|
||||
(hashwert) =>
|
||||
{
|
||||
let paar : {schluessel : typ_schluessel; wert : typ_wert;} = hashmap.speicher[hashwert];
|
||||
prozedur(paar.schluessel, paar.wert);
|
||||
}
|
||||
)
|
||||
;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -47,10 +47,10 @@ module mod_vtm
|
|||
(
|
||||
sprache =>
|
||||
{
|
||||
let zeichenketten_roh_ : schnittstelle_fehlermonade<any> = mod_vtm_daten.lesen("zeichenketten-" + sprache);
|
||||
if (zeichenketten_roh_.ist_schlicht())
|
||||
let zeichenketten_roh_ : lib_fehlermonade.typ_fehlermonade<any> = mod_vtm_daten.lesen("zeichenketten-" + sprache);
|
||||
if (lib_fehlermonade.voll(zeichenketten_roh_))
|
||||
{
|
||||
let zeichenketten_roh : {[schluessel : string] : string} = (<{[schluessel : string] : string}>(zeichenketten_roh_.lesen()));
|
||||
let zeichenketten_roh : {[schluessel : string] : string} = (<{[schluessel : string] : string}>(lib_fehlermonade.lesen(zeichenketten_roh_)));
|
||||
_daten[sprache] = {};
|
||||
for (let schluessel in zeichenketten_roh)
|
||||
{
|
||||
|
|
@ -72,27 +72,27 @@ module mod_vtm
|
|||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
function lesen(sprache : string, schluessel : string) : schnittstelle_fehlermonade<string>
|
||||
function lesen(sprache : string, schluessel : string) : lib_fehlermonade.typ_fehlermonade<string>
|
||||
{
|
||||
if (sprache in _daten)
|
||||
{
|
||||
let satz : {[schluessel : string] : string} = _daten[sprache];
|
||||
if (schluessel in satz)
|
||||
{
|
||||
return (new klasse_schlicht<string>(satz[schluessel]));
|
||||
return (lib_fehlermonade.mod_schlicht.erstellen<string>(satz[schluessel]));
|
||||
}
|
||||
else
|
||||
{
|
||||
let meldung : string = ("keine Zeichenketten für Schlüssel '" + schluessel + "' in Sprache '" + sprache + "'");
|
||||
console.warn(meldung);
|
||||
return (new klasse_nichts<string>());
|
||||
return (lib_fehlermonade.mod_nichts.erstellen<string>());
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
let meldung : string = ("keine Zeichenketten für Sprache '" + sprache + "'");
|
||||
console.warn(meldung);
|
||||
return (new klasse_nichts<string>());
|
||||
return (lib_fehlermonade.mod_nichts.erstellen<string>());
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -102,15 +102,15 @@ module mod_vtm
|
|||
*/
|
||||
export function holen(schluessel : string, vars : {[name : string] : string} = {}) : string
|
||||
{
|
||||
let ergebnis : schnittstelle_fehlermonade<string> = (new klasse_nichts<string>());
|
||||
let ergebnis : lib_fehlermonade.typ_fehlermonade<string> = (lib_fehlermonade.mod_nichts.erstellen<string>());
|
||||
let gefunden : boolean = (
|
||||
_sprachstapel
|
||||
.some
|
||||
(
|
||||
sprache =>
|
||||
{
|
||||
let ergebnis_ : schnittstelle_fehlermonade<string> = lesen(sprache, schluessel);
|
||||
if (ergebnis_.ist_schlicht())
|
||||
let ergebnis_ : lib_fehlermonade.typ_fehlermonade<string> = lesen(sprache, schluessel);
|
||||
if (lib_fehlermonade.voll(ergebnis_))
|
||||
{
|
||||
ergebnis = ergebnis_;
|
||||
return true;
|
||||
|
|
@ -124,7 +124,7 @@ module mod_vtm
|
|||
);
|
||||
if (gefunden)
|
||||
{
|
||||
let str : string = ergebnis.lesen();
|
||||
let str : string = lib_fehlermonade.lesen(ergebnis);
|
||||
for (let name in vars)
|
||||
{
|
||||
let muster : RegExp = (new RegExp("!var:" + name));
|
||||
|
|
|
|||
|
|
@ -16,37 +16,47 @@
|
|||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
module mod_vtm_helfer
|
||||
module mod_vtm
|
||||
{
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export type typ_xmlknoten = typ_komplex<any>;
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export type schnittstelle_xmlknoten =
|
||||
export module mod_helfer
|
||||
{
|
||||
darstellen : (xmlknoten : typ_xmlknoten, tiefe : int)=>string;
|
||||
}
|
||||
;
|
||||
|
||||
export module mod_xml
|
||||
{
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export type typ_knoten = typ_komplex<any>;
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export var implementierung_xmlknoten : {[art : string] : schnittstelle_xmlknoten} = {};
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export type signatur_knoten =
|
||||
{
|
||||
darstellen : (knoten : typ_knoten, tiefe : int)=>string;
|
||||
}
|
||||
;
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export function xmlknoten_darstellen(xmlknoten : typ_xmlknoten, tiefe : int = 0) : string
|
||||
{
|
||||
return implementierung_xmlknoten[xmlknoten.art].darstellen(xmlknoten, tiefe);
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export var brauch_knoten : lib_brauch.typ_brauch<signatur_knoten> = lib_brauch.erstellen<signatur_knoten>();
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export function darstellen(knoten : typ_knoten, tiefe : int = 0) : string
|
||||
{
|
||||
return lib_brauch.anwenden(brauch_knoten, knoten.art)["darstellen"](knoten, tiefe);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,117 +16,138 @@
|
|||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
module mod_vtm_helfer
|
||||
module mod_vtm
|
||||
{
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
function einrueckung(tiefe : int, zeichen : string = "\t") : string
|
||||
export module mod_helfer
|
||||
{
|
||||
return ((tiefe === 0) ? "" : (zeichen + einrueckung(tiefe-1)));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export type typ_xmlknoten_normal =
|
||||
{
|
||||
name : string;
|
||||
attribute : {[schluessel : string] : string};
|
||||
kinder : Array<typ_xmlknoten>;
|
||||
}
|
||||
;
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
function xmlknoten_normal_erstellen
|
||||
(
|
||||
name : string,
|
||||
attribute : {[schluessel : string] : string} = {},
|
||||
kinder : Array<typ_xmlknoten> = []
|
||||
)
|
||||
: typ_xmlknoten_normal
|
||||
{
|
||||
return {
|
||||
"name": name,
|
||||
"attribute": attribute,
|
||||
"kinder": kinder
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export function xmlknoten_normal_erstellen_erweitert
|
||||
(
|
||||
name : string,
|
||||
attribute : {[schluessel : string] : string} = {},
|
||||
kinder : Array<typ_xmlknoten> = []
|
||||
)
|
||||
: typ_xmlknoten
|
||||
{
|
||||
return {
|
||||
"art": "normal",
|
||||
"angaben": xmlknoten_normal_erstellen(name, attribute, kinder)
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
function xmlknoten_normal_darstellen(xmlknoten_normal : typ_xmlknoten_normal, tiefe : int) : string
|
||||
{
|
||||
let str : string = "";
|
||||
// anfang
|
||||
{
|
||||
let str_anfang : string = "";
|
||||
str_anfang += xmlknoten_normal.name;
|
||||
// attribute
|
||||
export module mod_xml
|
||||
{
|
||||
let str_attribute : string = "";
|
||||
Object.keys(xmlknoten_normal.attribute).forEach
|
||||
(
|
||||
schluessel =>
|
||||
|
||||
export module mod_normal
|
||||
{
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
function einrueckung(tiefe : int, zeichen : string = "\t") : string
|
||||
{
|
||||
let wert : string = xmlknoten_normal.attribute[schluessel];
|
||||
str_attribute += (" " + schluessel + "=" + "\"" + wert + "\"");
|
||||
return ((tiefe === 0) ? "" : (zeichen + einrueckung(tiefe-1)));
|
||||
}
|
||||
)
|
||||
;
|
||||
str_anfang += str_attribute;
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export type typ_normal =
|
||||
{
|
||||
name : string;
|
||||
attribute : {[schluessel : string] : string};
|
||||
kinder : Array<typ_knoten>;
|
||||
}
|
||||
;
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
function erstellen
|
||||
(
|
||||
name : string,
|
||||
attribute : {[schluessel : string] : string} = {},
|
||||
kinder : Array<typ_knoten> = []
|
||||
)
|
||||
: typ_normal
|
||||
{
|
||||
return {
|
||||
"name": name,
|
||||
"attribute": attribute,
|
||||
"kinder": kinder
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export function erstellen_erweitert
|
||||
(
|
||||
name : string,
|
||||
attribute : {[schluessel : string] : string} = {},
|
||||
kinder : Array<typ_knoten> = []
|
||||
)
|
||||
: typ_knoten
|
||||
{
|
||||
return einpacken("normal", erstellen(name, attribute, kinder));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
function darstellen
|
||||
(
|
||||
normal : typ_normal,
|
||||
tiefe : int
|
||||
)
|
||||
: string
|
||||
{
|
||||
let str : string = "";
|
||||
// anfang
|
||||
{
|
||||
let str_anfang : string = "";
|
||||
str_anfang += normal.name;
|
||||
// attribute
|
||||
{
|
||||
let str_attribute : string = "";
|
||||
Object.keys(normal.attribute).forEach
|
||||
(
|
||||
schluessel =>
|
||||
{
|
||||
let wert : string = normal.attribute[schluessel];
|
||||
str_attribute += (" " + schluessel + "=" + ("\"" + wert + "\""));
|
||||
}
|
||||
)
|
||||
;
|
||||
str_anfang += str_attribute;
|
||||
}
|
||||
str_anfang = (einrueckung(tiefe) + "<" + str_anfang + ">" + "\n");
|
||||
str += str_anfang;
|
||||
}
|
||||
// kinder
|
||||
{
|
||||
normal.kinder.forEach(kind => (str += mod_xml.darstellen(kind, tiefe+1)));
|
||||
}
|
||||
// ende
|
||||
{
|
||||
let str_ende : string = "";
|
||||
str_ende += normal.name;
|
||||
str_ende = (einrueckung(tiefe) + "<" + "/" + str_ende + ">" + "\n");
|
||||
str += str_ende;
|
||||
}
|
||||
return str;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
lib_brauch.umsetzen<signatur_knoten>
|
||||
(
|
||||
brauch_knoten,
|
||||
"normal",
|
||||
{
|
||||
"darstellen": (knoten, tiefe) => darstellen(knoten.angaben, tiefe),
|
||||
}
|
||||
)
|
||||
;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
str_anfang = (einrueckung(tiefe) + "<" + str_anfang + ">" + "\n");
|
||||
str += str_anfang;
|
||||
}
|
||||
// kinder
|
||||
{
|
||||
xmlknoten_normal.kinder.forEach(kind => (str += xmlknoten_darstellen(kind, tiefe+1)));
|
||||
}
|
||||
// ende
|
||||
{
|
||||
let str_ende : string = "";
|
||||
str_ende += xmlknoten_normal.name;
|
||||
str_ende = (einrueckung(tiefe) + "<" + "/" + str_ende + ">" + "\n");
|
||||
str += str_ende;
|
||||
}
|
||||
return str;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
implementierung_xmlknoten["normal"] =
|
||||
{
|
||||
"darstellen": (xmlknoten, tiefe) => xmlknoten_normal_darstellen(xmlknoten.angaben, tiefe),
|
||||
}
|
||||
;
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -16,54 +16,88 @@
|
|||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
module mod_vtm_helfer
|
||||
module mod_vtm
|
||||
{
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export type typ_xmlknoten_text =
|
||||
export module mod_helfer
|
||||
{
|
||||
inhalt : string
|
||||
|
||||
export module mod_xml
|
||||
{
|
||||
|
||||
export module mod_text
|
||||
{
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export type typ_text =
|
||||
{
|
||||
inhalt : string
|
||||
}
|
||||
;
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
function erstellen
|
||||
(
|
||||
inhalt : string
|
||||
)
|
||||
: typ_text
|
||||
{
|
||||
return {
|
||||
"inhalt": inhalt
|
||||
};
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export function erstellen_erweitert
|
||||
(
|
||||
inhalt : string
|
||||
)
|
||||
: typ_knoten
|
||||
{
|
||||
return einpacken("text", erstellen(inhalt));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
function darstellen
|
||||
(
|
||||
knoten : typ_text,
|
||||
tiefe : int
|
||||
)
|
||||
: string
|
||||
{
|
||||
return knoten.inhalt;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
lib_brauch.umsetzen<signatur_knoten>
|
||||
(
|
||||
brauch_knoten,
|
||||
"text",
|
||||
{
|
||||
"darstellen": (knoten, tiefe) => darstellen(knoten.angaben, tiefe),
|
||||
}
|
||||
)
|
||||
;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
;
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
function xmlknoten_text_erstellen(inhalt : string) : typ_xmlknoten_text
|
||||
{
|
||||
return {"inhalt": inhalt};
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
export function xmlknoten_text_erstellen_erweitert(inhalt : string) : typ_xmlknoten
|
||||
{
|
||||
return {"art": "text", "angaben": xmlknoten_text_erstellen(inhalt)};
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
function xmlknoten_text_darstellen(xmlknoten_text : typ_xmlknoten_text, tiefe : int) : string
|
||||
{
|
||||
return xmlknoten_text.inhalt;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
implementierung_xmlknoten["text"] =
|
||||
{
|
||||
"darstellen": (xmlknoten, tiefe) => xmlknoten_text_darstellen(xmlknoten.angaben, tiefe),
|
||||
}
|
||||
;
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -76,10 +76,10 @@ module mod_vtm
|
|||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
function darstellen(aktor_ : typ_aktor) : mod_vtm_helfer.typ_xmlknoten
|
||||
function darstellen(aktor_ : typ_aktor) : mod_vtm.mod_helfer.mod_xml.typ_knoten
|
||||
{
|
||||
let aktor : mod_vtm.mod_aufbau.mod_aktor.typ_aktor = aktor_.aufbau;
|
||||
let knoten_rahmen = function () : mod_vtm_helfer.typ_xmlknoten
|
||||
let knoten_rahmen = function () : mod_vtm.mod_helfer.mod_xml.typ_knoten
|
||||
{
|
||||
return (
|
||||
pfad
|
||||
|
|
@ -93,7 +93,7 @@ module mod_vtm
|
|||
);
|
||||
}
|
||||
;
|
||||
let kinder_feld : Array<mod_vtm_helfer.typ_xmlknoten> = [];
|
||||
let kinder_feld : Array<mod_vtm.mod_helfer.mod_xml.typ_knoten> = [];
|
||||
fallunterscheidung<void>
|
||||
(
|
||||
aktor,
|
||||
|
|
@ -102,8 +102,8 @@ module mod_vtm
|
|||
{
|
||||
kinder_feld.push(knoten_rahmen());
|
||||
let richtung : mod_vtm.mod_aufbau.mod_richtung.typ_richtung = mod_vtm.mod_aufbau.mod_aktor_erzeuger.richtung_lesen(angaben);
|
||||
let knoten_pfeil : mod_vtm_helfer.typ_xmlknoten = (
|
||||
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert
|
||||
let knoten_pfeil : mod_vtm.mod_helfer.mod_xml.typ_knoten = (
|
||||
mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
|
||||
(
|
||||
"path",
|
||||
{
|
||||
|
|
@ -131,8 +131,8 @@ module mod_vtm
|
|||
{
|
||||
kinder_feld.push(knoten_rahmen());
|
||||
let richtung : mod_vtm.mod_aufbau.mod_richtung.typ_richtung = mod_vtm.mod_aufbau.mod_aktor_befoerderer.richtung_lesen(angaben);
|
||||
let knoten_pfeil : mod_vtm_helfer.typ_xmlknoten = (
|
||||
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert
|
||||
let knoten_pfeil : mod_vtm.mod_helfer.mod_xml.typ_knoten = (
|
||||
mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
|
||||
(
|
||||
"path",
|
||||
{
|
||||
|
|
@ -161,8 +161,8 @@ module mod_vtm
|
|||
kinder_feld.push(knoten_rahmen());
|
||||
let richtung : mod_vtm.mod_aufbau.mod_richtung.typ_richtung = mod_vtm.mod_aufbau.mod_aktor_schreiber.richtung_lesen(angaben);
|
||||
let symbol : mod_vtm.mod_aufbau.mod_symbol.typ_symbol = mod_vtm.mod_aufbau.mod_aktor_schreiber.symbol_lesen(angaben);
|
||||
let knoten_pfeil : mod_vtm_helfer.typ_xmlknoten = (
|
||||
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert
|
||||
let knoten_pfeil : mod_vtm.mod_helfer.mod_xml.typ_knoten = (
|
||||
mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
|
||||
(
|
||||
"path",
|
||||
{
|
||||
|
|
@ -192,19 +192,19 @@ module mod_vtm
|
|||
let richtung : mod_vtm.mod_aufbau.mod_richtung.typ_richtung = mod_vtm.mod_aufbau.mod_aktor_leser.richtung_lesen(angaben);
|
||||
let symbol_links : mod_vtm.mod_aufbau.mod_symbol.typ_symbol = mod_vtm.mod_aufbau.mod_aktor_leser.symbol_links_lesen(angaben);
|
||||
let symbol_rechts : mod_vtm.mod_aufbau.mod_symbol.typ_symbol = mod_vtm.mod_aufbau.mod_aktor_leser.symbol_rechts_lesen(angaben);
|
||||
let ausgaenge : Array<{summand : mod_vtm.mod_aufbau.mod_richtung.typ_richtung, symbol : schnittstelle_fehlermonade<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>;}> =
|
||||
let ausgaenge : Array<{summand : mod_vtm.mod_aufbau.mod_richtung.typ_richtung, symbol : lib_fehlermonade.typ_fehlermonade<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>;}> =
|
||||
[
|
||||
{
|
||||
"summand": 0,
|
||||
"symbol": new klasse_nichts<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>(),
|
||||
"symbol": lib_fehlermonade.mod_nichts.erstellen<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>(),
|
||||
},
|
||||
{
|
||||
"summand": +2,
|
||||
"symbol": new klasse_schlicht<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>(symbol_links),
|
||||
"symbol": lib_fehlermonade.mod_schlicht.erstellen<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>(symbol_links),
|
||||
},
|
||||
{
|
||||
"summand": -2,
|
||||
"symbol": new klasse_schlicht<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>(symbol_rechts),
|
||||
"symbol": lib_fehlermonade.mod_schlicht.erstellen<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>(symbol_rechts),
|
||||
},
|
||||
]
|
||||
;
|
||||
|
|
@ -213,8 +213,8 @@ module mod_vtm
|
|||
eintrag =>
|
||||
{
|
||||
let winkel : float = ((mod_vtm.mod_aufbau.mod_richtung.addieren(richtung, eintrag.summand) / 6) * 360);
|
||||
let knoten_pfeil : mod_vtm_helfer.typ_xmlknoten = (
|
||||
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert
|
||||
let knoten_pfeil : mod_vtm.mod_helfer.mod_xml.typ_knoten = (
|
||||
mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
|
||||
(
|
||||
"path",
|
||||
{
|
||||
|
|
@ -223,8 +223,8 @@ module mod_vtm
|
|||
[
|
||||
"pfeil",
|
||||
(
|
||||
eintrag.symbol.ist_schlicht()
|
||||
? "symbol_" + eintrag.symbol.lesen().toFixed(0)
|
||||
lib_fehlermonade.voll(eintrag.symbol)
|
||||
? "symbol_" + lib_fehlermonade.lesen(eintrag.symbol).toFixed(0)
|
||||
: "neutral"
|
||||
),
|
||||
].join(" ")
|
||||
|
|
@ -249,8 +249,8 @@ module mod_vtm
|
|||
"verwerfer": (angaben) =>
|
||||
{
|
||||
kinder_feld.push(knoten_rahmen());
|
||||
let knoten_kreis : mod_vtm_helfer.typ_xmlknoten = (
|
||||
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert
|
||||
let knoten_kreis : mod_vtm.mod_helfer.mod_xml.typ_knoten = (
|
||||
mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
|
||||
(
|
||||
"circle",
|
||||
{
|
||||
|
|
@ -272,8 +272,8 @@ module mod_vtm
|
|||
"annehmer": (angaben) =>
|
||||
{
|
||||
kinder_feld.push(knoten_rahmen());
|
||||
let knoten_kreis : mod_vtm_helfer.typ_xmlknoten = (
|
||||
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert
|
||||
let knoten_kreis : mod_vtm.mod_helfer.mod_xml.typ_knoten = (
|
||||
mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
|
||||
(
|
||||
"circle",
|
||||
{
|
||||
|
|
@ -296,8 +296,8 @@ module mod_vtm
|
|||
)
|
||||
;
|
||||
let position : mod_position.typ_position = mod_position.von_stelle(aktor_.stelle);
|
||||
let knoten_feld : mod_vtm_helfer.typ_xmlknoten = (
|
||||
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert
|
||||
let knoten_feld : mod_vtm.mod_helfer.mod_xml.typ_knoten = (
|
||||
mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
|
||||
(
|
||||
"g",
|
||||
{
|
||||
|
|
|
|||
|
|
@ -76,14 +76,14 @@ module mod_vtm
|
|||
(
|
||||
figur_ : typ_figur
|
||||
)
|
||||
: mod_vtm_helfer.typ_xmlknoten
|
||||
: mod_vtm.mod_helfer.mod_xml.typ_knoten
|
||||
{
|
||||
let figur : mod_vtm.mod_aufbau.mod_figur.typ_figur = figur_.aufbau;
|
||||
let kinder_figur : Array<mod_vtm_helfer.typ_xmlknoten> = [];
|
||||
let kinder_figur : Array<mod_vtm.mod_helfer.mod_xml.typ_knoten> = [];
|
||||
// Stein
|
||||
{
|
||||
let knoten_stein : mod_vtm_helfer.typ_xmlknoten = (
|
||||
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert
|
||||
let knoten_stein : mod_vtm.mod_helfer.mod_xml.typ_knoten = (
|
||||
mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
|
||||
(
|
||||
"circle",
|
||||
{
|
||||
|
|
@ -99,7 +99,7 @@ module mod_vtm
|
|||
// Band
|
||||
{
|
||||
let band : Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol> = mod_vtm.mod_aufbau.mod_figur.band_lesen(figur);
|
||||
let kinder_band : Array<mod_vtm_helfer.typ_xmlknoten> = [];
|
||||
let kinder_band : Array<mod_vtm.mod_helfer.mod_xml.typ_knoten> = [];
|
||||
band.forEach
|
||||
(
|
||||
(symbol, index) =>
|
||||
|
|
@ -107,8 +107,8 @@ module mod_vtm
|
|||
let r : float = 0.06125;
|
||||
let x : float = (+0.1+(2*r*1.25)*index);
|
||||
let y : float = (-0.1);
|
||||
let knoten_eintrag : mod_vtm_helfer.typ_xmlknoten = (
|
||||
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert
|
||||
let knoten_eintrag : mod_vtm.mod_helfer.mod_xml.typ_knoten = (
|
||||
mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
|
||||
(
|
||||
"circle",
|
||||
{
|
||||
|
|
@ -135,7 +135,7 @@ module mod_vtm
|
|||
)
|
||||
;
|
||||
let knoten_band = (
|
||||
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert
|
||||
mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
|
||||
(
|
||||
"g",
|
||||
{
|
||||
|
|
@ -148,7 +148,7 @@ module mod_vtm
|
|||
}
|
||||
let position : mod_position.typ_position = mod_position.von_stelle(mod_vtm.mod_aufbau.mod_figur.stelle_lesen(figur));
|
||||
let knoten_figur = (
|
||||
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert
|
||||
mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
|
||||
(
|
||||
"g",
|
||||
{
|
||||
|
|
|
|||
|
|
@ -64,27 +64,27 @@ module mod_vtm
|
|||
/**
|
||||
* @author kcf <vidofnir@folksprak.org>
|
||||
*/
|
||||
function darstellen(partie : typ_partie) : mod_vtm_helfer.typ_xmlknoten
|
||||
function darstellen(partie : typ_partie) : mod_vtm.mod_helfer.mod_xml.typ_knoten
|
||||
{
|
||||
let kinder_partie : Array<mod_vtm_helfer.typ_xmlknoten> = [];
|
||||
let kinder_partie : Array<mod_vtm.mod_helfer.mod_xml.typ_knoten> = [];
|
||||
// Welt
|
||||
{
|
||||
let kinder_welt : Array<mod_vtm_helfer.typ_xmlknoten> = [];
|
||||
let kinder_welt : Array<mod_vtm.mod_helfer.mod_xml.typ_knoten> = [];
|
||||
// Felder
|
||||
{
|
||||
let kinder_felder : Array<mod_vtm_helfer.typ_xmlknoten> = [];
|
||||
let kinder_felder : Array<mod_vtm.mod_helfer.mod_xml.typ_knoten> = [];
|
||||
mod_vtm.mod_aufbau.mod_welt.felder_lesen(mod_vtm.mod_aufbau.mod_partie.welt_lesen(partie.aufbau)).forEach
|
||||
(
|
||||
({"stelle": stelle, "aktor": aktor}) =>
|
||||
{
|
||||
let manifestation_feld : typ_manifestation<mod_vtm.mod_aufbau.mod_aktor.typ_aktor> = mod_aktor.erstellen_manifestation(aktor, stelle);
|
||||
let knoten_feld : mod_vtm_helfer.typ_xmlknoten = mod_manifestation.darstellen(manifestation_feld);
|
||||
let knoten_feld : mod_vtm.mod_helfer.mod_xml.typ_knoten = mod_manifestation.darstellen(manifestation_feld);
|
||||
kinder_felder.push(knoten_feld);
|
||||
}
|
||||
)
|
||||
;
|
||||
let knoten_felder : mod_vtm_helfer.typ_xmlknoten = (
|
||||
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert
|
||||
let knoten_felder : mod_vtm.mod_helfer.mod_xml.typ_knoten = (
|
||||
mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
|
||||
(
|
||||
"g",
|
||||
{
|
||||
|
|
@ -96,8 +96,8 @@ module mod_vtm
|
|||
);
|
||||
kinder_welt.push(knoten_felder);
|
||||
}
|
||||
let knoten_welt : mod_vtm_helfer.typ_xmlknoten = (
|
||||
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert
|
||||
let knoten_welt : mod_vtm.mod_helfer.mod_xml.typ_knoten = (
|
||||
mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
|
||||
(
|
||||
"g",
|
||||
{
|
||||
|
|
@ -110,12 +110,12 @@ module mod_vtm
|
|||
}
|
||||
// Figur
|
||||
{
|
||||
let figur_ : schnittstelle_fehlermonade<mod_vtm.mod_aufbau.mod_figur.typ_figur> = mod_vtm.mod_aufbau.mod_partie.figur_lesen(partie.aufbau);
|
||||
if (figur_.ist_schlicht())
|
||||
let figur_ : lib_fehlermonade.typ_fehlermonade<mod_vtm.mod_aufbau.mod_figur.typ_figur> = mod_vtm.mod_aufbau.mod_partie.figur_lesen(partie.aufbau);
|
||||
if (lib_fehlermonade.voll(figur_))
|
||||
{
|
||||
let figur : mod_vtm.mod_aufbau.mod_figur.typ_figur = figur_.lesen();
|
||||
let figur : mod_vtm.mod_aufbau.mod_figur.typ_figur = lib_fehlermonade.lesen(figur_);
|
||||
let manifestation_figur : typ_manifestation<mod_vtm.mod_aufbau.mod_figur.typ_figur> = mod_figur.erstellen_manifestation(figur);
|
||||
let knoten_figur : mod_vtm_helfer.typ_xmlknoten = mod_manifestation.darstellen(manifestation_figur);
|
||||
let knoten_figur : mod_vtm.mod_helfer.mod_xml.typ_knoten = mod_manifestation.darstellen(manifestation_figur);
|
||||
kinder_partie.push(knoten_figur);
|
||||
}
|
||||
else
|
||||
|
|
@ -123,8 +123,8 @@ module mod_vtm
|
|||
// nichts tun
|
||||
}
|
||||
}
|
||||
let knoten_partie : mod_vtm_helfer.typ_xmlknoten = (
|
||||
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert
|
||||
let knoten_partie : mod_vtm.mod_helfer.mod_xml.typ_knoten = (
|
||||
mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
|
||||
(
|
||||
"g",
|
||||
{
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@ module mod_vtm
|
|||
schliessen : boolean = true,
|
||||
attribute : {[schlussel : string] : string} = {},
|
||||
)
|
||||
: mod_vtm_helfer.typ_xmlknoten
|
||||
: mod_vtm.mod_helfer.mod_xml.typ_knoten
|
||||
{
|
||||
let d : string = "";
|
||||
vertices.forEach
|
||||
|
|
@ -63,7 +63,7 @@ module mod_vtm
|
|||
if (schliessen)
|
||||
d += "Z";
|
||||
attribute["d"] = d;
|
||||
return (mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert("path", attribute));
|
||||
return (mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert("path", attribute));
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -78,12 +78,12 @@ module mod_vtm
|
|||
bis_y : float,
|
||||
hoehe : int = 500,
|
||||
breite : int = 500,
|
||||
kinder : Array<mod_vtm_helfer.typ_xmlknoten> = []
|
||||
kinder : Array<mod_vtm.mod_helfer.mod_xml.typ_knoten> = []
|
||||
)
|
||||
: mod_vtm_helfer.typ_xmlknoten
|
||||
: mod_vtm.mod_helfer.mod_xml.typ_knoten
|
||||
{
|
||||
return (
|
||||
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert
|
||||
mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
|
||||
(
|
||||
"svg",
|
||||
{
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ module mod_vtm
|
|||
{
|
||||
aufbau : mod_aufbau.mod_partie.typ_partie;
|
||||
bereich : Element;
|
||||
intervall : schnittstelle_fehlermonade<any>;
|
||||
intervall : lib_fehlermonade.typ_fehlermonade<any>;
|
||||
}
|
||||
;
|
||||
|
||||
|
|
@ -63,7 +63,7 @@ module mod_vtm
|
|||
return {
|
||||
"aufbau": aufbau,
|
||||
"bereich": bereich,
|
||||
"intervall": (new klasse_nichts<any>()),
|
||||
"intervall": (lib_fehlermonade.mod_nichts.erstellen<any>()),
|
||||
};
|
||||
}
|
||||
|
||||
|
|
@ -107,7 +107,7 @@ module mod_vtm
|
|||
*/
|
||||
function erneuern_welt(partie : typ_partie) : void
|
||||
{
|
||||
let knoten_svg : mod_vtm_helfer.typ_xmlknoten = mod_svg.wurzel
|
||||
let knoten_svg : mod_vtm.mod_helfer.mod_xml.typ_knoten = mod_svg.wurzel
|
||||
(
|
||||
-4, -4,
|
||||
+4, +4,
|
||||
|
|
@ -115,7 +115,7 @@ module mod_vtm
|
|||
[mod_manifestation.darstellen(mod_svg.mod_partie.erstellen_manifestation(partie.aufbau))]
|
||||
)
|
||||
;
|
||||
partie.bereich.innerHTML = mod_vtm_helfer.xmlknoten_darstellen(knoten_svg);
|
||||
partie.bereich.innerHTML = mod_vtm.mod_helfer.mod_xml.darstellen(knoten_svg);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -124,7 +124,7 @@ module mod_vtm
|
|||
*/
|
||||
function erneuern_figur(partie : typ_partie) : void
|
||||
{
|
||||
let knoten_svg : mod_vtm_helfer.typ_xmlknoten = mod_svg.wurzel
|
||||
let knoten_svg : mod_vtm.mod_helfer.mod_xml.typ_knoten = mod_svg.wurzel
|
||||
(
|
||||
-4, -4,
|
||||
+4, +4,
|
||||
|
|
@ -132,7 +132,7 @@ module mod_vtm
|
|||
[mod_manifestation.darstellen(mod_svg.mod_partie.erstellen_manifestation(partie.aufbau))]
|
||||
)
|
||||
;
|
||||
partie.bereich.innerHTML = mod_vtm_helfer.xmlknoten_darstellen(knoten_svg);
|
||||
partie.bereich.innerHTML = mod_vtm.mod_helfer.mod_xml.darstellen(knoten_svg);
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -192,7 +192,7 @@ module mod_vtm
|
|||
case mod_vtm.mod_aufbau.mod_modus.ungewiss:
|
||||
{
|
||||
klasse = (
|
||||
partie.intervall.ist_schlicht()
|
||||
lib_fehlermonade.lesen(partie.intervall)
|
||||
? "ungewiss_laufend"
|
||||
: "ungewiss_stehend"
|
||||
);
|
||||
|
|
@ -232,10 +232,10 @@ module mod_vtm
|
|||
*/
|
||||
function anhalten(partie : typ_partie) : void
|
||||
{
|
||||
if (partie.intervall.ist_schlicht())
|
||||
if (lib_fehlermonade.voll(partie.intervall))
|
||||
{
|
||||
clearInterval(partie.intervall.lesen());
|
||||
partie.intervall = (new klasse_nichts<any>());
|
||||
clearInterval(lib_fehlermonade.lesen(partie.intervall));
|
||||
partie.intervall = (lib_fehlermonade.mod_nichts.erstellen<any>());
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -271,7 +271,7 @@ module mod_vtm
|
|||
function testen(partie : typ_partie) : void
|
||||
{
|
||||
let handle : any = setInterval(() => fortfahren(partie), 500);
|
||||
partie.intervall = (new klasse_schlicht<any>(handle));
|
||||
partie.intervall = (lib_fehlermonade.mod_schlicht.erstellen<any>(handle));
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -302,16 +302,16 @@ module mod_vtm
|
|||
{
|
||||
let stelle_ermitteln = (target : EventTarget) =>
|
||||
{
|
||||
let stelle : schnittstelle_fehlermonade<mod_vtm.mod_aufbau.mod_stelle.typ_stelle>;
|
||||
let stelle : lib_fehlermonade.typ_fehlermonade<mod_vtm.mod_aufbau.mod_stelle.typ_stelle>;
|
||||
let dom_feld : Element = target["closest"](".feld");
|
||||
if (dom_feld == null)
|
||||
{
|
||||
stelle = (new klasse_nichts<mod_vtm.mod_aufbau.mod_stelle.typ_stelle>());
|
||||
stelle = (lib_fehlermonade.mod_nichts.erstellen<mod_vtm.mod_aufbau.mod_stelle.typ_stelle>());
|
||||
}
|
||||
else
|
||||
{
|
||||
let rel : string = dom_feld.getAttribute("rel")
|
||||
stelle = (new klasse_schlicht<mod_vtm.mod_aufbau.mod_stelle.typ_stelle>(mod_vtm.mod_aufbau.mod_stelle.von_hash(rel)));
|
||||
stelle = (lib_fehlermonade.mod_schlicht.erstellen<mod_vtm.mod_aufbau.mod_stelle.typ_stelle>(mod_vtm.mod_aufbau.mod_stelle.von_hash(rel)));
|
||||
}
|
||||
return stelle;
|
||||
}
|
||||
|
|
@ -364,10 +364,10 @@ module mod_vtm
|
|||
event =>
|
||||
{
|
||||
event.preventDefault();
|
||||
let stelle_ : schnittstelle_fehlermonade<mod_vtm.mod_aufbau.mod_stelle.typ_stelle> = stelle_ermitteln(event.target);
|
||||
if (stelle_.ist_schlicht())
|
||||
let stelle_ : lib_fehlermonade.typ_fehlermonade<mod_vtm.mod_aufbau.mod_stelle.typ_stelle> = stelle_ermitteln(event.target);
|
||||
if (lib_fehlermonade.voll(stelle_))
|
||||
{
|
||||
mod_vtm.mod_aufbau.mod_partie.welt_feld_wechseln(partie.aufbau, stelle_.lesen(), false);
|
||||
mod_vtm.mod_aufbau.mod_partie.welt_feld_wechseln(partie.aufbau, lib_fehlermonade.lesen(stelle_), false);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -383,10 +383,10 @@ module mod_vtm
|
|||
event =>
|
||||
{
|
||||
event.preventDefault();
|
||||
let stelle_ : schnittstelle_fehlermonade<mod_vtm.mod_aufbau.mod_stelle.typ_stelle> = stelle_ermitteln(event.target);
|
||||
if (stelle_.ist_schlicht())
|
||||
let stelle_ : lib_fehlermonade.typ_fehlermonade<mod_vtm.mod_aufbau.mod_stelle.typ_stelle> = stelle_ermitteln(event.target);
|
||||
if (lib_fehlermonade.voll(stelle_))
|
||||
{
|
||||
mod_vtm.mod_aufbau.mod_partie.welt_feld_wechseln(partie.aufbau, stelle_.lesen(), true);
|
||||
mod_vtm.mod_aufbau.mod_partie.welt_feld_wechseln(partie.aufbau, lib_fehlermonade.lesen(stelle_), true);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
@ -402,11 +402,11 @@ module mod_vtm
|
|||
event =>
|
||||
{
|
||||
event.preventDefault();
|
||||
let stelle_ : schnittstelle_fehlermonade<mod_vtm.mod_aufbau.mod_stelle.typ_stelle> = stelle_ermitteln(event.target);
|
||||
if (stelle_.ist_schlicht())
|
||||
let stelle_ : lib_fehlermonade.typ_fehlermonade<mod_vtm.mod_aufbau.mod_stelle.typ_stelle> = stelle_ermitteln(event.target);
|
||||
if (lib_fehlermonade.voll(stelle_))
|
||||
{
|
||||
let inkrement : int = ((event["deltaY"] < 0) ? -1 : +1);
|
||||
mod_vtm.mod_aufbau.mod_partie.welt_feld_drehen(partie.aufbau, stelle_.lesen(), inkrement);
|
||||
mod_vtm.mod_aufbau.mod_partie.welt_feld_drehen(partie.aufbau, lib_fehlermonade.lesen(stelle_), inkrement);
|
||||
}
|
||||
else
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
s:mod_vtm_helfer.sequenz:mod_vtm.mod_helfer.sequenz:g
|
||||
s:mod_vtm_helfer.liste_kopieren:mod_vtm.mod_helfer.liste_kopieren:g
|
||||
s:mod_vtm_helfer.typ_xmlknoten:mod_vtm.mod_helfer.mod_xml.typ_knoten:g
|
||||
s:mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert:mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert:g
|
||||
s:mod_vtm_helfer.xmlknoten_text_erstellen_erweitert:mod_vtm.mod_helfer.mod_xml.mod_text.erstellen_erweitert:g
|
||||
s:mod_vtm_helfer.xmlknoten_darstellen:mod_vtm.mod_helfer.mod_xml.darstellen:g
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue