misc/vtm
0
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

speicherung

Browse source
This commit is contained in:
Christian Fraß 2018-03-27 17:24:31 +02:00
parent 9b530f4940
commit dac259a252
24 changed files with 729 additions and 533 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

55
hilfe.md Normal file
View 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
View file

@ -25,17 +25,14 @@ ${dir_erzeugnis}/vtm.html: \
${dir_quelldatein}/manifestation/web/vtm.html ${dir_quelldatein}/manifestation/web/vtm.html
@ ${cmd_echo} "-- Struktur …" @ ${cmd_echo} "-- Struktur …"
@ ${cmd_md} ${dir_erzeugnis} @ ${cmd_md} ${dir_erzeugnis}
@ ${cmd_cp} ${dir_quelldatein}/manifestation/web/vtm.html ${dir_erzeugnis}/vtm.html @ ${cmd_cp} $^ $@
${dir_erzeugnis}/vtm.css: \ ${dir_erzeugnis}/vtm.css: \
${dir_quelldatein}/manifestation/web/vtm.scss \ ${dir_quelldatein}/manifestation/web/vtm.scss \
${dir_quelldatein}/manifestation/web/partie.scss ${dir_quelldatein}/manifestation/web/partie.scss
@ ${cmd_echo} "-- Gestaltung …" @ ${cmd_echo} "-- Gestaltung …"
@ ${cmd_md} ${dir_erzeugnis} @ ${cmd_md} ${dir_erzeugnis}
@ ${cmd_cat} \ @ ${cmd_cat} $^ | ${cmd_sass} --stdin > $@
${dir_quelldatein}/manifestation/web/vtm.scss \
${dir_quelldatein}/manifestation/web/partie.scss \
| ${cmd_sass} --stdin > ${dir_erzeugnis}/vtm.css
${dir_erzeugnis}/vtm.dat.js: \ ${dir_erzeugnis}/vtm.dat.js: \
${dir_quelldatein}/daten/aufgaben.dat.js \ ${dir_quelldatein}/daten/aufgaben.dat.js \
@ -43,23 +40,21 @@ ${dir_erzeugnis}/vtm.dat.js: \
${dir_quelldatein}/daten/zeichenketten/en.dat.js ${dir_quelldatein}/daten/zeichenketten/en.dat.js
@ ${cmd_echo} "-- Daten …" @ ${cmd_echo} "-- Daten …"
@ ${cmd_md} ${dir_erzeugnis} @ ${cmd_md} ${dir_erzeugnis}
@ ${cmd_cat} \ @ ${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
${dir_erzeugnis}/vtm.js: \ ${dir_erzeugnis}/vtm.js: \
${dir_quelldatein}/basis/typen.ts \ ${dir_quelldatein}/helfer/typen.ts \
${dir_quelldatein}/basis/fehlermonade.ts \ ${dir_quelldatein}/helfer/aufruf.ts \
${dir_quelldatein}/basis/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/verschiedenes.ts \
${dir_quelldatein}/helfer/mathematik.ts \ ${dir_quelldatein}/helfer/mathematik.ts \
${dir_quelldatein}/helfer/vektor.ts \ ${dir_quelldatein}/helfer/vektor.ts \
${dir_quelldatein}/helfer/hashmap.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}/helfer/uebersetzung.ts \
${dir_quelldatein}/daten.ts \ ${dir_quelldatein}/daten.ts \
${dir_quelldatein}/aufbau/richtung.ts \ ${dir_quelldatein}/aufbau/richtung.ts \
@ -94,48 +89,5 @@ ${dir_erzeugnis}/vtm.js: \
${dir_quelldatein}/haupt.ts ${dir_quelldatein}/haupt.ts
@ ${cmd_echo} "-- Logik …" @ ${cmd_echo} "-- Logik …"
@ ${cmd_md} ${dir_erzeugnis} @ ${cmd_md} ${dir_erzeugnis}
@ ${cmd_tsc} \ @ ${cmd_tsc} $^ --outFile $@
${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

6
quelldatein/aufbau/aktoren/leser.ts
View file

@ -152,11 +152,11 @@ module mod_vtm
) )
: void : 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; 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) if (symbol === leser.symbol_links)
{ {
mod_figur.schieben(figur); mod_figur.schieben(figur);

6
quelldatein/aufbau/figur.ts
View file

@ -130,15 +130,15 @@ module mod_vtm
( (
figur : typ_figur figur : typ_figur
) )
: schnittstelle_fehlermonade<mod_symbol.typ_symbol> : lib_fehlermonade.typ_fehlermonade<mod_symbol.typ_symbol>
{ {
if (figur.band.length <= 0) if (figur.band.length <= 0)
{ {
return (new klasse_nichts<mod_symbol.typ_symbol>()); return (lib_fehlermonade.mod_nichts.erstellen<mod_symbol.typ_symbol>());
} }
else 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]));
} }
} }

36
quelldatein/aufbau/partie.ts
View file

@ -31,9 +31,9 @@ module mod_vtm
export type typ_partie = export type typ_partie =
{ {
welt : mod_welt.typ_welt; 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; aufgabe : mod_aufgabe.typ_aufgabe;
testindex : schnittstelle_fehlermonade<int>; testindex : lib_fehlermonade.typ_fehlermonade<int>;
modus : mod_modus.typ_modus; modus : mod_modus.typ_modus;
lauscher : {[ereignis : string] : Array<(angaben ?: any)=>void>}; 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 export function zuruecksetzen(partie : typ_partie, bescheid_geben : boolean = true) : void
{ {
partie.figur = (new klasse_nichts<mod_figur.typ_figur>()); partie.figur = (lib_fehlermonade.mod_nichts.erstellen<mod_figur.typ_figur>());
partie.testindex = (new klasse_nichts<int>()); partie.testindex = (lib_fehlermonade.mod_nichts.erstellen<int>());
partie.modus = mod_modus.initial; partie.modus = mod_modus.initial;
if (bescheid_geben) if (bescheid_geben)
{ {
@ -197,7 +197,7 @@ module mod_vtm
/** /**
* @author kcf <vidofnir@folksprak.org> * @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; return partie.figur;
} }
@ -270,19 +270,19 @@ module mod_vtm
case mod_modus.initial: case mod_modus.initial:
{ {
partie.modus = mod_modus.ungewiss; 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", {}); benachrichtigen(partie, "aenderung_modus", {});
break; break;
} }
case mod_modus.ungewiss: 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 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); let stelle : mod_stelle.typ_stelle = mod_welt.erzeuger_finden(partie.welt);
partie.figur = ( partie.figur = (
new klasse_schlicht<mod_figur.typ_figur> lib_fehlermonade.mod_schlicht.erstellen<mod_figur.typ_figur>
( (
mod_figur.erstellen mod_figur.erstellen
( (
@ -294,10 +294,14 @@ module mod_vtm
} }
else 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 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_ : lib_fehlermonade.typ_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 : mod_aktor.typ_aktor = (
lib_fehlermonade.voll(aktor_)
? lib_fehlermonade.lesen(aktor_)
: mod_aktor_verwerfer.erstellen_aktor()
);
mod_aktor.verwenden(aktor, figur); mod_aktor.verwenden(aktor, figur);
let zustand : mod_zustand.typ_zustand = mod_figur.zustand_lesen(figur); let zustand : mod_zustand.typ_zustand = mod_figur.zustand_lesen(figur);
if (zustand === mod_zustand.laufend) if (zustand === mod_zustand.laufend)
@ -308,8 +312,8 @@ module mod_vtm
{ {
let angenommen : boolean = (zustand === mod_zustand.angenommen); let angenommen : boolean = (zustand === mod_zustand.angenommen);
let ausgabe : Array<mod_symbol.typ_symbol> = mod_figur.band_lesen(figur); let ausgabe : Array<mod_symbol.typ_symbol> = mod_figur.band_lesen(figur);
partie.figur = (new klasse_nichts<mod_figur.typ_figur>()); partie.figur = (lib_fehlermonade.mod_nichts.erstellen<mod_figur.typ_figur>());
let testindex : int = partie.testindex.lesen(); let testindex : int = lib_fehlermonade.lesen(partie.testindex);
let tests : Array<mod_test.typ_test> = mod_aufgabe.tests(partie.aufgabe); let tests : Array<mod_test.typ_test> = mod_aufgabe.tests(partie.aufgabe);
let test : mod_test.typ_test = tests[testindex]; let test : mod_test.typ_test = tests[testindex];
if (! mod_test.pruefen(test, angenommen, ausgabe)) if (! mod_test.pruefen(test, angenommen, ausgabe))
@ -323,12 +327,12 @@ module mod_vtm
if (testindex < tests.length) if (testindex < tests.length)
{ {
// nächsten Test auswählen // nächsten Test auswählen
partie.testindex = (new klasse_schlicht<int>(testindex)); partie.testindex = (lib_fehlermonade.mod_schlicht.erstellen<int>(testindex));
} }
else else
{ {
// auf Modus "korrekt" wechseln // auf Modus "korrekt" wechseln
partie.testindex = (new klasse_nichts<int>()); partie.testindex = (lib_fehlermonade.mod_nichts.erstellen<int>());
partie.modus = mod_modus.korrekt; partie.modus = mod_modus.korrekt;
benachrichtigen(partie, "aenderung_modus", {}); benachrichtigen(partie, "aenderung_modus", {});
} }

59
quelldatein/aufbau/welt.ts
View file

@ -30,7 +30,7 @@ module mod_vtm
*/ */
export type typ_welt = 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 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 : 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;}> 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;}> = []; 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}) (stelle, aktor) => felder.push({"stelle": stelle, "aktor": aktor})
) )
; ;
@ -68,9 +69,9 @@ module mod_vtm
/** /**
* @author kcf <vidofnir@folksprak.org> * @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 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 index_alt : lib_fehlermonade.typ_fehlermonade<int>;
let aktor_alt_ : schnittstelle_fehlermonade<mod_aktor.typ_aktor> = welt.felder.holen(stelle); let aktor_alt_ : lib_fehlermonade.typ_fehlermonade<mod_aktor.typ_aktor> = mod_vtm.mod_helfer.mod_hashmap.holen(welt.felder, stelle);
if (aktor_alt_.ist_schlicht()) 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 = ( let gefunden : boolean = (
liste.some liste.some
( (
@ -177,7 +178,7 @@ module mod_vtm
{ {
if (eintrag.pruefer(aktor_alt)) if (eintrag.pruefer(aktor_alt))
{ {
index_alt = (new klasse_schlicht<int>(index)); index_alt = (lib_fehlermonade.mod_schlicht.erstellen<int>(index));
return true; return true;
} }
else else
@ -189,7 +190,7 @@ module mod_vtm
); );
if (! gefunden) if (! gefunden)
{ {
index_alt = (new klasse_nichts<int>()); index_alt = (lib_fehlermonade.mod_nichts.erstellen<int>());
} }
else else
{ {
@ -200,11 +201,11 @@ module mod_vtm
{ {
let meldung : string = "kein Aktor gesetzt"; let meldung : string = "kein Aktor gesetzt";
// console.warn(meldung); // 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(); let aktor_neu : mod_aktor.typ_aktor = liste[index_neu].ersteller();
feld_setzen(welt, stelle, aktor_neu); 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 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); let aktor_ : lib_fehlermonade.typ_fehlermonade<mod_aktor.typ_aktor> = mod_vtm.mod_helfer.mod_hashmap.holen(welt.felder, stelle);
if (aktor_.ist_schlicht) if (lib_fehlermonade.voll(aktor_))
{ {
mod_aktor.drehen(aktor_.lesen(), inkrement); mod_aktor.drehen(lib_fehlermonade.lesen(aktor_), inkrement);
} }
else else
{ {
@ -240,29 +241,30 @@ module mod_vtm
*/ */
export function erzeuger_finden(welt : typ_welt) : mod_stelle.typ_stelle 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>()); let stelle : lib_fehlermonade.typ_fehlermonade<mod_stelle.typ_stelle> = (lib_fehlermonade.mod_nichts.erstellen<mod_stelle.typ_stelle>());
welt.felder.iterieren mod_vtm.mod_helfer.mod_hashmap.iterieren
( (
welt.felder,
(stelle_, aktor) => (stelle_, aktor) =>
{ {
if (aktor.art === "erzeuger") if (aktor.art === "erzeuger")
{ {
if (stelle.ist_schlicht()) if (lib_fehlermonade.voll(stelle))
{ {
let meldung : string = "mehrere Erzeuger gefunden"; let meldung : string = "mehrere Erzeuger gefunden";
throw (new Error(meldung)); throw (new Error(meldung));
} }
else 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 else
{ {
@ -298,7 +300,7 @@ module mod_vtm
{ {
aktor = mod_aktor_verwerfer.erstellen_aktor(); 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 = {}; let roh : any = {};
roh["felder"] = {}; roh["felder"] = {};
welt.felder.iterieren mod_vtm.mod_helfer.mod_hashmap.iterieren
( (
welt.felder,
(stelle, aktor) => (stelle, aktor) =>
{ {
let stelle_ : string = mod_stelle.exportieren(stelle); let stelle_ : string = mod_stelle.exportieren(stelle);
@ -332,13 +335,13 @@ module mod_vtm
*/ */
export function importieren(roh : any) : typ_welt 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"]) for (let stelle_ in roh["felder"])
{ {
let stelle : mod_stelle.typ_stelle = mod_stelle.importieren(stelle_); 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 = roh["felder"][stelle_];
let aktor : mod_aktor.typ_aktor = mod_aktor.importieren(aktor_); 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 ( return (
erstellen erstellen

6
quelldatein/daten.ts
View file

@ -37,15 +37,15 @@ module mod_vtm_daten
/** /**
* @author kcf <vidofnir@folksprak.org> * @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) if (schluessel in _speicher)
{ {
return (new klasse_schlicht<any>(_speicher[schluessel])); return (lib_fehlermonade.mod_schlicht.erstellen<any>(_speicher[schluessel]));
} }
else else
{ {
return (new klasse_nichts<any>()); return (lib_fehlermonade.mod_nichts.erstellen<any>());
} }
} }

10
quelldatein/haupt.ts
View file

@ -24,10 +24,10 @@ module mod_vtm
*/ */
function aufgaben_eintragen(behandler : (aufgabe : mod_aufbau.mod_aufgabe.typ_aufgabe)=>void) : void 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"); let aufgaben_roh_ : lib_fehlermonade.typ_fehlermonade<Array<any>> = mod_vtm_daten.lesen("aufgaben");
if (aufgaben_roh_.ist_schlicht()) 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"); let dom_auswahl : Element = document.querySelector("#aufgabe_auswahl");
aufgaben_roh.forEach aufgaben_roh.forEach
( (
@ -153,7 +153,7 @@ module mod_vtm
mod_aufbau.mod_stelle.null_() 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 mod_manifestation.mod_svg.wurzel
( (
von_x, von_y, von_x, von_y,
@ -162,7 +162,7 @@ module mod_vtm
[mod_manifestation.darstellen(manifestation)] [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);
} }
) )
; ;

64
quelldatein/basis/aufruf.ts → quelldatein/helfer/aufruf.ts
View file

@ -47,7 +47,7 @@ function fallunterscheidung<typ_ergebnis>
( (
komplex : typ_komplex<any>, komplex : typ_komplex<any>,
faelle : {[art : string] : (angaben ?: any)=>typ_ergebnis}, 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 : typ_ergebnis
{ {
@ -61,16 +61,60 @@ function fallunterscheidung<typ_ergebnis>
{ {
let meldung : string = ("unbehandelte Art '" + komplex.art + "'"); let meldung : string = ("unbehandelte Art '" + komplex.art + "'");
console.warn(meldung); console.warn(meldung);
if (ersatz.ist_schlicht()) let ergebnis : typ_ergebnis = ersatz(komplex);
{ return ergebnis;
let ergebnis : typ_ergebnis = ersatz.lesen()(komplex);
return ergebnis;
}
else
{
throw (new Error("unbehandelt"));
}
} }
} }
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];
}
}

97
quelldatein/basis/fehlermonade.ts → quelldatein/helfer/fehlermonade/_fehlermonade.ts
View file

@ -16,100 +16,47 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>. * along with this program. If not, see <https://www.gnu.org/licenses/>.
*/ */
/** module lib_fehlermonade
* @author kcf <vidofnir@folksprak.org>
*/
interface schnittstelle_fehlermonade<typ_wert>
{ {
/** /**
* @author kcf <vidofnir@folksprak.org> * @author kcf <vidofnir@folksprak.org>
*/ */
ist_schlicht() : boolean; export type typ_fehlermonade<typ_wert> = typ_komplex<typ_wert>;
/** /**
* @author kcf <vidofnir@folksprak.org> * @author kcf <vidofnir@folksprak.org>
*/ */
lesen() : typ_wert; export type signatur_fehlermonade<typ_wert> =
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
class klasse_nichts<typ_wert>
implements schnittstelle_fehlermonade<typ_wert>
{
/**
* @author kcf <vidofnir@folksprak.org>
*/
public constructor()
{ {
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> * @author kcf <vidofnir@folksprak.org>
*/ */
public ist_schlicht() : boolean export function lesen<typ_wert>(fehlermonade : typ_fehlermonade<typ_wert>) : typ_wert
{ {
return false; return lib_brauch.anwenden(brauch_fehlermonade, fehlermonade.art)["lesen"](fehlermonade);
}
/**
* @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;
} }
} }

51
quelldatein/helfer/fehlermonade/nichts.ts Normal file
View 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
View 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,
}
)
;
}
}

152
quelldatein/helfer/hashmap.ts
View file

@ -16,82 +16,104 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>. * along with this program. If not, see <https://www.gnu.org/licenses/>.
*/ */
module mod_vtm_helfer module mod_vtm
{ {
/** export module mod_helfer
* @author kcf <vidofnir@folksprak.org>
*/
export class klasse_hashmap<typ_schluessel, typ_wert>
{ {
/** export module mod_hashmap
* @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)
{ {
this.hashfunction = hashfunction;
this.speicher = {};
}
/**
/** * @author kcf <vidofnir@folksprak.org>
* @author kcf <vidofnir@folksprak.org> */
*/ export type typ_hashmap<typ_schluessel, typ_wert> =
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)
{ {
let wert : typ_wert = this.speicher[hashwert].wert; hashfunction : (schluessel : typ_schluessel)=>string;
return (new klasse_schlicht<typ_wert>(wert)); 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);
}
)
;
}
} }
} }
} }

0
quelldatein/basis/typen.ts → quelldatein/helfer/typen.ts
View file

22
quelldatein/helfer/uebersetzung.ts
View file

@ -47,10 +47,10 @@ module mod_vtm
( (
sprache => sprache =>
{ {
let zeichenketten_roh_ : schnittstelle_fehlermonade<any> = mod_vtm_daten.lesen("zeichenketten-" + sprache); let zeichenketten_roh_ : lib_fehlermonade.typ_fehlermonade<any> = mod_vtm_daten.lesen("zeichenketten-" + sprache);
if (zeichenketten_roh_.ist_schlicht()) 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] = {}; _daten[sprache] = {};
for (let schluessel in zeichenketten_roh) for (let schluessel in zeichenketten_roh)
{ {
@ -72,27 +72,27 @@ module mod_vtm
/** /**
* @author kcf <vidofnir@folksprak.org> * @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) if (sprache in _daten)
{ {
let satz : {[schluessel : string] : string} = _daten[sprache]; let satz : {[schluessel : string] : string} = _daten[sprache];
if (schluessel in satz) if (schluessel in satz)
{ {
return (new klasse_schlicht<string>(satz[schluessel])); return (lib_fehlermonade.mod_schlicht.erstellen<string>(satz[schluessel]));
} }
else else
{ {
let meldung : string = ("keine Zeichenketten für Schlüssel '" + schluessel + "' in Sprache '" + sprache + "'"); let meldung : string = ("keine Zeichenketten für Schlüssel '" + schluessel + "' in Sprache '" + sprache + "'");
console.warn(meldung); console.warn(meldung);
return (new klasse_nichts<string>()); return (lib_fehlermonade.mod_nichts.erstellen<string>());
} }
} }
else else
{ {
let meldung : string = ("keine Zeichenketten für Sprache '" + sprache + "'"); let meldung : string = ("keine Zeichenketten für Sprache '" + sprache + "'");
console.warn(meldung); 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 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 = ( let gefunden : boolean = (
_sprachstapel _sprachstapel
.some .some
( (
sprache => sprache =>
{ {
let ergebnis_ : schnittstelle_fehlermonade<string> = lesen(sprache, schluessel); let ergebnis_ : lib_fehlermonade.typ_fehlermonade<string> = lesen(sprache, schluessel);
if (ergebnis_.ist_schlicht()) if (lib_fehlermonade.voll(ergebnis_))
{ {
ergebnis = ergebnis_; ergebnis = ergebnis_;
return true; return true;
@ -124,7 +124,7 @@ module mod_vtm
); );
if (gefunden) if (gefunden)
{ {
let str : string = ergebnis.lesen(); let str : string = lib_fehlermonade.lesen(ergebnis);
for (let name in vars) for (let name in vars)
{ {
let muster : RegExp = (new RegExp("!var:" + name)); let muster : RegExp = (new RegExp("!var:" + name));

58
quelldatein/helfer/xmlknoten/_xmlknoten.ts
View file

@ -16,37 +16,47 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>. * along with this program. If not, see <https://www.gnu.org/licenses/>.
*/ */
module mod_vtm_helfer module mod_vtm
{ {
/** export module mod_helfer
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_xmlknoten = typ_komplex<any>;
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type schnittstelle_xmlknoten =
{ {
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> * @author kcf <vidofnir@folksprak.org>
*/ */
export var implementierung_xmlknoten : {[art : string] : schnittstelle_xmlknoten} = {}; export type signatur_knoten =
{
darstellen : (knoten : typ_knoten, tiefe : int)=>string;
}
;
/** /**
* @author kcf <vidofnir@folksprak.org> * @author kcf <vidofnir@folksprak.org>
*/ */
export function xmlknoten_darstellen(xmlknoten : typ_xmlknoten, tiefe : int = 0) : string export var brauch_knoten : lib_brauch.typ_brauch<signatur_knoten> = lib_brauch.erstellen<signatur_knoten>();
{
return implementierung_xmlknoten[xmlknoten.art].darstellen(xmlknoten, tiefe);
/**
* @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);
}
}
} }
} }

223
quelldatein/helfer/xmlknoten/normal.ts
View file

@ -16,117 +16,138 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>. * along with this program. If not, see <https://www.gnu.org/licenses/>.
*/ */
module mod_vtm_helfer module mod_vtm
{ {
/** export module mod_helfer
* @author kcf <vidofnir@folksprak.org>
*/
function einrueckung(tiefe : int, zeichen : string = "\t") : string
{ {
return ((tiefe === 0) ? "" : (zeichen + einrueckung(tiefe-1)));
}
export module mod_xml
/**
* @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
{ {
let str_attribute : string = "";
Object.keys(xmlknoten_normal.attribute).forEach export module mod_normal
( {
schluessel =>
/**
* @author kcf <vidofnir@folksprak.org>
*/
function einrueckung(tiefe : int, zeichen : string = "\t") : string
{ {
let wert : string = xmlknoten_normal.attribute[schluessel]; return ((tiefe === 0) ? "" : (zeichen + einrueckung(tiefe-1)));
str_attribute += (" " + schluessel + "=" + "\"" + wert + "\"");
} }
)
;
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),
} }
;
} }

122
quelldatein/helfer/xmlknoten/text.ts
View file

@ -16,54 +16,88 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>. * along with this program. If not, see <https://www.gnu.org/licenses/>.
*/ */
module mod_vtm_helfer module mod_vtm
{ {
/** export module mod_helfer
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_xmlknoten_text =
{ {
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),
}
;
} }

46
quelldatein/manifestation/svg/aktor.ts
View file

@ -76,10 +76,10 @@ module mod_vtm
/** /**
* @author kcf <vidofnir@folksprak.org> * @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 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 ( return (
pfad 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> fallunterscheidung<void>
( (
aktor, aktor,
@ -102,8 +102,8 @@ module mod_vtm
{ {
kinder_feld.push(knoten_rahmen()); 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 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 = ( let knoten_pfeil : mod_vtm.mod_helfer.mod_xml.typ_knoten = (
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
( (
"path", "path",
{ {
@ -131,8 +131,8 @@ module mod_vtm
{ {
kinder_feld.push(knoten_rahmen()); 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 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 = ( let knoten_pfeil : mod_vtm.mod_helfer.mod_xml.typ_knoten = (
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
( (
"path", "path",
{ {
@ -161,8 +161,8 @@ module mod_vtm
kinder_feld.push(knoten_rahmen()); 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 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 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 = ( let knoten_pfeil : mod_vtm.mod_helfer.mod_xml.typ_knoten = (
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
( (
"path", "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 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_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 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, "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, "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, "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 => eintrag =>
{ {
let winkel : float = ((mod_vtm.mod_aufbau.mod_richtung.addieren(richtung, eintrag.summand) / 6) * 360); let winkel : float = ((mod_vtm.mod_aufbau.mod_richtung.addieren(richtung, eintrag.summand) / 6) * 360);
let knoten_pfeil : mod_vtm_helfer.typ_xmlknoten = ( let knoten_pfeil : mod_vtm.mod_helfer.mod_xml.typ_knoten = (
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
( (
"path", "path",
{ {
@ -223,8 +223,8 @@ module mod_vtm
[ [
"pfeil", "pfeil",
( (
eintrag.symbol.ist_schlicht() lib_fehlermonade.voll(eintrag.symbol)
? "symbol_" + eintrag.symbol.lesen().toFixed(0) ? "symbol_" + lib_fehlermonade.lesen(eintrag.symbol).toFixed(0)
: "neutral" : "neutral"
), ),
].join(" ") ].join(" ")
@ -249,8 +249,8 @@ module mod_vtm
"verwerfer": (angaben) => "verwerfer": (angaben) =>
{ {
kinder_feld.push(knoten_rahmen()); kinder_feld.push(knoten_rahmen());
let knoten_kreis : mod_vtm_helfer.typ_xmlknoten = ( let knoten_kreis : mod_vtm.mod_helfer.mod_xml.typ_knoten = (
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
( (
"circle", "circle",
{ {
@ -272,8 +272,8 @@ module mod_vtm
"annehmer": (angaben) => "annehmer": (angaben) =>
{ {
kinder_feld.push(knoten_rahmen()); kinder_feld.push(knoten_rahmen());
let knoten_kreis : mod_vtm_helfer.typ_xmlknoten = ( let knoten_kreis : mod_vtm.mod_helfer.mod_xml.typ_knoten = (
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
( (
"circle", "circle",
{ {
@ -296,8 +296,8 @@ module mod_vtm
) )
; ;
let position : mod_position.typ_position = mod_position.von_stelle(aktor_.stelle); let position : mod_position.typ_position = mod_position.von_stelle(aktor_.stelle);
let knoten_feld : mod_vtm_helfer.typ_xmlknoten = ( let knoten_feld : mod_vtm.mod_helfer.mod_xml.typ_knoten = (
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
( (
"g", "g",
{ {

18
quelldatein/manifestation/svg/figur.ts
View file

@ -76,14 +76,14 @@ module mod_vtm
( (
figur_ : typ_figur 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 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 // Stein
{ {
let knoten_stein : mod_vtm_helfer.typ_xmlknoten = ( let knoten_stein : mod_vtm.mod_helfer.mod_xml.typ_knoten = (
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
( (
"circle", "circle",
{ {
@ -99,7 +99,7 @@ module mod_vtm
// Band // Band
{ {
let band : Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol> = mod_vtm.mod_aufbau.mod_figur.band_lesen(figur); 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 band.forEach
( (
(symbol, index) => (symbol, index) =>
@ -107,8 +107,8 @@ module mod_vtm
let r : float = 0.06125; let r : float = 0.06125;
let x : float = (+0.1+(2*r*1.25)*index); let x : float = (+0.1+(2*r*1.25)*index);
let y : float = (-0.1); let y : float = (-0.1);
let knoten_eintrag : mod_vtm_helfer.typ_xmlknoten = ( let knoten_eintrag : mod_vtm.mod_helfer.mod_xml.typ_knoten = (
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
( (
"circle", "circle",
{ {
@ -135,7 +135,7 @@ module mod_vtm
) )
; ;
let knoten_band = ( let knoten_band = (
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
( (
"g", "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 position : mod_position.typ_position = mod_position.von_stelle(mod_vtm.mod_aufbau.mod_figur.stelle_lesen(figur));
let knoten_figur = ( let knoten_figur = (
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
( (
"g", "g",
{ {

30
quelldatein/manifestation/svg/partie.ts
View file

@ -64,27 +64,27 @@ module mod_vtm
/** /**
* @author kcf <vidofnir@folksprak.org> * @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 // Welt
{ {
let kinder_welt : Array<mod_vtm_helfer.typ_xmlknoten> = []; let kinder_welt : Array<mod_vtm.mod_helfer.mod_xml.typ_knoten> = [];
// Felder // 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 mod_vtm.mod_aufbau.mod_welt.felder_lesen(mod_vtm.mod_aufbau.mod_partie.welt_lesen(partie.aufbau)).forEach
( (
({"stelle": stelle, "aktor": aktor}) => ({"stelle": stelle, "aktor": aktor}) =>
{ {
let manifestation_feld : typ_manifestation<mod_vtm.mod_aufbau.mod_aktor.typ_aktor> = mod_aktor.erstellen_manifestation(aktor, stelle); 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); kinder_felder.push(knoten_feld);
} }
) )
; ;
let knoten_felder : mod_vtm_helfer.typ_xmlknoten = ( let knoten_felder : mod_vtm.mod_helfer.mod_xml.typ_knoten = (
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
( (
"g", "g",
{ {
@ -96,8 +96,8 @@ module mod_vtm
); );
kinder_welt.push(knoten_felder); kinder_welt.push(knoten_felder);
} }
let knoten_welt : mod_vtm_helfer.typ_xmlknoten = ( let knoten_welt : mod_vtm.mod_helfer.mod_xml.typ_knoten = (
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
( (
"g", "g",
{ {
@ -110,12 +110,12 @@ module mod_vtm
} }
// Figur // Figur
{ {
let figur_ : schnittstelle_fehlermonade<mod_vtm.mod_aufbau.mod_figur.typ_figur> = mod_vtm.mod_aufbau.mod_partie.figur_lesen(partie.aufbau); 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 (figur_.ist_schlicht()) 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 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); kinder_partie.push(knoten_figur);
} }
else else
@ -123,8 +123,8 @@ module mod_vtm
// nichts tun // nichts tun
} }
} }
let knoten_partie : mod_vtm_helfer.typ_xmlknoten = ( let knoten_partie : mod_vtm.mod_helfer.mod_xml.typ_knoten = (
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
( (
"g", "g",
{ {

10
quelldatein/manifestation/svg/svg.ts
View file

@ -46,7 +46,7 @@ module mod_vtm
schliessen : boolean = true, schliessen : boolean = true,
attribute : {[schlussel : string] : string} = {}, attribute : {[schlussel : string] : string} = {},
) )
: mod_vtm_helfer.typ_xmlknoten : mod_vtm.mod_helfer.mod_xml.typ_knoten
{ {
let d : string = ""; let d : string = "";
vertices.forEach vertices.forEach
@ -63,7 +63,7 @@ module mod_vtm
if (schliessen) if (schliessen)
d += "Z"; d += "Z";
attribute["d"] = d; 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, bis_y : float,
hoehe : int = 500, hoehe : int = 500,
breite : 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 ( return (
mod_vtm_helfer.xmlknoten_normal_erstellen_erweitert mod_vtm.mod_helfer.mod_xml.mod_normal.erstellen_erweitert
( (
"svg", "svg",
{ {

46
quelldatein/manifestation/web/partie.ts
View file

@ -45,7 +45,7 @@ module mod_vtm
{ {
aufbau : mod_aufbau.mod_partie.typ_partie; aufbau : mod_aufbau.mod_partie.typ_partie;
bereich : Element; bereich : Element;
intervall : schnittstelle_fehlermonade<any>; intervall : lib_fehlermonade.typ_fehlermonade<any>;
} }
; ;
@ -63,7 +63,7 @@ module mod_vtm
return { return {
"aufbau": aufbau, "aufbau": aufbau,
"bereich": bereich, "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 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,
+4, +4, +4, +4,
@ -115,7 +115,7 @@ module mod_vtm
[mod_manifestation.darstellen(mod_svg.mod_partie.erstellen_manifestation(partie.aufbau))] [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 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,
+4, +4, +4, +4,
@ -132,7 +132,7 @@ module mod_vtm
[mod_manifestation.darstellen(mod_svg.mod_partie.erstellen_manifestation(partie.aufbau))] [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: case mod_vtm.mod_aufbau.mod_modus.ungewiss:
{ {
klasse = ( klasse = (
partie.intervall.ist_schlicht() lib_fehlermonade.lesen(partie.intervall)
? "ungewiss_laufend" ? "ungewiss_laufend"
: "ungewiss_stehend" : "ungewiss_stehend"
); );
@ -232,10 +232,10 @@ module mod_vtm
*/ */
function anhalten(partie : typ_partie) : void function anhalten(partie : typ_partie) : void
{ {
if (partie.intervall.ist_schlicht()) if (lib_fehlermonade.voll(partie.intervall))
{ {
clearInterval(partie.intervall.lesen()); clearInterval(lib_fehlermonade.lesen(partie.intervall));
partie.intervall = (new klasse_nichts<any>()); partie.intervall = (lib_fehlermonade.mod_nichts.erstellen<any>());
} }
else else
{ {
@ -271,7 +271,7 @@ module mod_vtm
function testen(partie : typ_partie) : void function testen(partie : typ_partie) : void
{ {
let handle : any = setInterval(() => fortfahren(partie), 500); 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_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"); let dom_feld : Element = target["closest"](".feld");
if (dom_feld == null) 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 else
{ {
let rel : string = dom_feld.getAttribute("rel") 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; return stelle;
} }
@ -364,10 +364,10 @@ module mod_vtm
event => event =>
{ {
event.preventDefault(); event.preventDefault();
let stelle_ : schnittstelle_fehlermonade<mod_vtm.mod_aufbau.mod_stelle.typ_stelle> = stelle_ermitteln(event.target); let stelle_ : lib_fehlermonade.typ_fehlermonade<mod_vtm.mod_aufbau.mod_stelle.typ_stelle> = stelle_ermitteln(event.target);
if (stelle_.ist_schlicht()) 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 else
{ {
@ -383,10 +383,10 @@ module mod_vtm
event => event =>
{ {
event.preventDefault(); event.preventDefault();
let stelle_ : schnittstelle_fehlermonade<mod_vtm.mod_aufbau.mod_stelle.typ_stelle> = stelle_ermitteln(event.target); let stelle_ : lib_fehlermonade.typ_fehlermonade<mod_vtm.mod_aufbau.mod_stelle.typ_stelle> = stelle_ermitteln(event.target);
if (stelle_.ist_schlicht()) 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 else
{ {
@ -402,11 +402,11 @@ module mod_vtm
event => event =>
{ {
event.preventDefault(); event.preventDefault();
let stelle_ : schnittstelle_fehlermonade<mod_vtm.mod_aufbau.mod_stelle.typ_stelle> = stelle_ermitteln(event.target); let stelle_ : lib_fehlermonade.typ_fehlermonade<mod_vtm.mod_aufbau.mod_stelle.typ_stelle> = stelle_ermitteln(event.target);
if (stelle_.ist_schlicht()) if (lib_fehlermonade.voll(stelle_))
{ {
let inkrement : int = ((event["deltaY"] < 0) ? -1 : +1); 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 else
{ {

6
werkzeuge/anpassen.sed
View file

@ -1,3 +1,5 @@
s:mod_vtm_helfer.sequenz:mod_vtm.mod_helfer.sequenz:g s:mod_vtm_helfer.typ_xmlknoten:mod_vtm.mod_helfer.mod_xml.typ_knoten:g
s:mod_vtm_helfer.liste_kopieren:mod_vtm.mod_helfer.liste_kopieren: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