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

zwischenspeicherung

Browse source
This commit is contained in:
Christian Fraß 2018-03-26 10:42:58 +02:00
parent 74a9792bbf
commit 48b556057c
20 changed files with 2090 additions and 1906 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

139
quelldatein/aufbau/aktoren/_aktor.ts
View file

@ -16,88 +16,99 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
module mod_vtm_aufbau
module mod_vtm
{
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_aktor = typ_komplex<any>;
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type schnittstelle_aktor =
export module mod_aufbau
{
beispiel : ()=>typ_aktor;
drehen : (aktor : typ_aktor, inkrement : int)=>void;
verwenden : (aktor : typ_aktor, figur : typ_figur)=>void;
exportieren : (aktor : typ_aktor)=>any;
importieren : (roh : any)=>typ_aktor;
}
;
export module mod_aktor
{
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_aktor = typ_komplex<any>;
/**
* @author kcf <vidofnir@folksprak.org>
*/
export var implementierung_aktor : {[art : string] : schnittstelle_aktor} = {};
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type schnittstelle_aktor =
{
beispiel : ()=>typ_aktor;
drehen : (aktor : typ_aktor, inkrement : int)=>void;
verwenden : (aktor : typ_aktor, figur : mod_figur.typ_figur)=>void;
exportieren : (aktor : typ_aktor)=>any;
importieren : (roh : any)=>typ_aktor;
}
;
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function aktor_erstellen(art : string, kern : any) : typ_aktor
{
return {"art": art, "angaben": kern};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export var implementierung_aktor : {[art : string] : schnittstelle_aktor} = {};
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function aktor_beispiel(art : string) : typ_aktor
{
return implementierung_aktor[art].beispiel();
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
/*
export function erstellen(art : string, kern : any) : typ_aktor
{
return einpacken(art, kern);
}
*/
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function aktor_drehen(aktor : typ_aktor, inkrement ?: int) : void
{
return implementierung_aktor[aktor.art].drehen(aktor, inkrement);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function beispiel(art : string) : typ_aktor
{
return implementierung_aktor[art].beispiel();
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function aktor_verwenden(aktor : typ_aktor, figur : typ_figur) : void
{
return implementierung_aktor[aktor.art].verwenden(aktor, figur);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function drehen(aktor : typ_aktor, inkrement ?: int) : void
{
return implementierung_aktor[aktor.art].drehen(aktor, inkrement);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function aktor_exportieren(aktor : typ_aktor) : any
{
return implementierung_aktor[aktor.art].exportieren(aktor);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function verwenden(aktor : typ_aktor, figur : mod_figur.typ_figur) : void
{
return implementierung_aktor[aktor.art].verwenden(aktor, figur);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function aktor_importieren(roh : any) : typ_aktor
{
return implementierung_aktor[roh.art].importieren(roh);
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function exportieren(aktor : typ_aktor) : any
{
return implementierung_aktor[aktor.art].exportieren(aktor);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function importieren(roh : any) : typ_aktor
{
return implementierung_aktor[roh.art].importieren(roh);
}
}
}
}

249
quelldatein/aufbau/aktoren/annehmer.ts
View file

@ -16,128 +16,141 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
module mod_vtm_aufbau
module mod_vtm
{
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_annehmer =
export module mod_aufbau
{
export module mod_aktor_annehmer
{
/**
* @author kcf <vidofnir@folksprak.org>
*/
let art : string = "annehmer";
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_annehmer =
{
}
;
/**
* @author kcf <vidofnir@folksprak.org>
*/
function erstellen
(
)
: typ_annehmer
{
return {
};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function erstellen_aktor
(
)
: mod_aktor.typ_aktor
{
return einpacken(art, erstellen());
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function beispiel
(
)
: typ_annehmer
{
return erstellen();
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function drehen
(
annehmer : typ_annehmer,
inkrement ?: int
)
: void
{
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function verwenden
(
annehmer : typ_annehmer,
figur : mod_figur.typ_figur
)
: void
{
mod_figur.annehmen(figur);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function exportieren
(
annehmer : typ_annehmer
)
: any
{
return {
};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function importieren
(
roh : any
)
: typ_annehmer
{
return (
erstellen
(
)
);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
mod_aktor.implementierung_aktor[art] =
{
"beispiel": () => einpacken(art, beispiel()),
"drehen": (aktor, inkrement) => drehen(auspacken(aktor), inkrement),
"verwenden": (aktor, figur) => verwenden(auspacken(aktor), figur),
"exportieren": (aktor) => ({"art": art, "angaben": exportieren(aktor.angaben)}),
"importieren": (roh) => einpacken(art, importieren(roh)),
}
;
}
}
;
/**
* @author kcf <vidofnir@folksprak.org>
*/
function annehmer_erstellen
(
)
: typ_annehmer
{
return {
};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function annehmer_erstellen_aktor
(
)
: typ_aktor
{
return {"art": "annehmer", "angaben": annehmer_erstellen()};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function annehmer_beispiel
(
)
: typ_annehmer
{
return annehmer_erstellen();
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function annehmer_drehen
(
annehmer : typ_annehmer,
inkrement ?: int
)
: void
{
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function annehmer_verwenden
(
annehmer : typ_annehmer,
figur : typ_figur
)
: void
{
figur_annehmen(figur);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function annehmer_exportieren
(
annehmer : typ_annehmer
)
: any
{
return {
};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function annehmer_importieren
(
roh : any
)
: typ_annehmer
{
return (
annehmer_erstellen
(
)
);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
let wrap = (angaben => ({"art": "annehmer", "angaben": angaben}));
let unwrap = (aktor => aktor.angaben);
implementierung_aktor["annehmer"] =
{
"beispiel": () => wrap(annehmer_beispiel()),
"drehen": (aktor, inkrement) => annehmer_drehen(unwrap(aktor), inkrement),
"verwenden": (aktor, figur) => annehmer_verwenden(unwrap(aktor), figur),
"exportieren": (aktor) => ({"art": "annehmer_", "angaben": annehmer_exportieren(aktor.angaben)}),
"importieren": (roh) => wrap(annehmer_importieren(roh)),
}
;
}

289
quelldatein/aufbau/aktoren/befoerderer.ts
View file

@ -16,148 +16,161 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
module mod_vtm_aufbau
module mod_vtm
{
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_befoerderer =
export module mod_aufbau
{
richtung : typ_richtung;
export module mod_aktor_befoerderer
{
/**
* @author kcf <vidofnir@folksprak.org>
*/
let art : string = "befoerderer";
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_befoerderer =
{
richtung : mod_richtung.typ_richtung;
}
;
/**
* @author kcf <vidofnir@folksprak.org>
*/
function erstellen
(
richtung : mod_richtung.typ_richtung
)
: typ_befoerderer
{
return {
"richtung": richtung,
};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function erstellen_aktor
(
richtung : mod_richtung.typ_richtung
)
: mod_aktor.typ_aktor
{
return einpacken(art, erstellen(richtung));
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function beispiel
(
)
: typ_befoerderer
{
return erstellen(0);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function richtung_lesen
(
befoerderer : typ_befoerderer
)
: mod_richtung.typ_richtung
{
return befoerderer.richtung;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function drehen
(
befoerderer : typ_befoerderer,
inkrement : int = +1
)
: void
{
befoerderer.richtung = mod_richtung.addieren(befoerderer.richtung, inkrement);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function verwenden
(
befoerderer : typ_befoerderer,
figur : mod_figur.typ_figur
)
: void
{
mod_figur.bewegen(figur, befoerderer.richtung);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function exportieren
(
befoerderer : typ_befoerderer
)
: any
{
return {
"richtung": mod_richtung.exportieren(befoerderer.richtung),
};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function importieren
(
roh : any
)
: typ_befoerderer
{
return (
erstellen
(
mod_richtung.importieren(roh["richtung"])
)
);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
mod_aktor.implementierung_aktor[art] =
{
"beispiel": () => einpacken(art, beispiel()),
"drehen": (aktor, inkrement) => drehen(auspacken(aktor), inkrement),
"verwenden": (aktor, figur) => verwenden(auspacken(aktor), figur),
"exportieren": (aktor) => ({"art": art, "angaben": exportieren(aktor.angaben)}),
"importieren": (roh) => einpacken(art, importieren(roh)),
}
;
}
}
;
/**
* @author kcf <vidofnir@folksprak.org>
*/
function befoerderer_erstellen
(
richtung : typ_richtung
)
: typ_befoerderer
{
return {
"richtung": richtung,
};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function befoerderer_erstellen_aktor
(
richtung : typ_richtung
)
: typ_aktor
{
return {"art": "befoerderer", "angaben": befoerderer_erstellen(richtung)};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function befoerderer_beispiel
(
)
: typ_befoerderer
{
return befoerderer_erstellen(0);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function befoerderer_richtung_lesen
(
befoerderer : typ_befoerderer
)
: typ_richtung
{
return befoerderer.richtung;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function befoerderer_drehen
(
befoerderer : typ_befoerderer,
inkrement : int = +1
)
: void
{
befoerderer.richtung = richtung_addieren(befoerderer.richtung, inkrement);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function befoerderer_verwenden
(
befoerderer : typ_befoerderer,
figur : typ_figur
)
: void
{
figur_bewegen(figur, befoerderer.richtung);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function befoerderer_exportieren
(
befoerderer : typ_befoerderer
)
: any
{
return {
"richtung": richtung_exportieren(befoerderer.richtung),
};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function befoerderer_importieren
(
roh : any
)
: typ_befoerderer
{
return (
befoerderer_erstellen
(
richtung_importieren(roh["richtung"])
)
);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
let wrap = (angaben => ({"art": "befoerderer", "angaben": angaben}));
let unwrap = (aktor => aktor.angaben);
implementierung_aktor["befoerderer"] =
{
"beispiel": () => wrap(befoerderer_beispiel()),
"drehen": (aktor, inkrement) => befoerderer_drehen(unwrap(aktor), inkrement),
"verwenden": (aktor, figur) => befoerderer_verwenden(unwrap(aktor), figur),
"exportieren": (aktor) => ({"art": "befoerderer", "angaben": befoerderer_exportieren(aktor.angaben)}),
"importieren": (roh) => wrap(befoerderer_importieren(roh)),
}
;
}

289
quelldatein/aufbau/aktoren/erzeuger.ts
View file

@ -16,148 +16,161 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
module mod_vtm_aufbau
module mod_vtm
{
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_erzeuger =
export module mod_aufbau
{
richtung : typ_richtung;
export module mod_aktor_erzeuger
{
/**
* @author kcf <vidofnir@folksprak.org>
*/
let art : string = "erzeuger";
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_erzeuger =
{
richtung : mod_richtung.typ_richtung;
}
;
/**
* @author kcf <vidofnir@folksprak.org>
*/
function erstellen
(
richtung : mod_richtung.typ_richtung
)
: typ_erzeuger
{
return {
"richtung": richtung,
};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function erstellen_aktor
(
richtung : mod_richtung.typ_richtung
)
: mod_aktor.typ_aktor
{
return einpacken(art, erstellen(richtung));
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function beispiel
(
)
: typ_erzeuger
{
return erstellen(0);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function richtung_lesen
(
erzeuger : typ_erzeuger
)
: mod_richtung.typ_richtung
{
return erzeuger.richtung;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function drehen
(
erzeuger : typ_erzeuger,
inkrement : int = +1
)
: void
{
erzeuger.richtung = mod_richtung.addieren(erzeuger.richtung, inkrement);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function verwenden
(
erzeuger : typ_erzeuger,
figur : mod_figur.typ_figur
)
: void
{
mod_figur.bewegen(figur, erzeuger.richtung);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function exportieren
(
erzeuger : typ_erzeuger
)
: any
{
return {
"richtung": mod_richtung.exportieren(erzeuger.richtung),
};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function importieren
(
roh : any
)
: typ_erzeuger
{
return (
erstellen
(
mod_richtung.importieren(roh["richtung"])
)
);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
mod_aktor.implementierung_aktor[art] =
{
"beispiel": () => einpacken(art, beispiel()),
"drehen": (aktor, inkrement) => drehen(auspacken(aktor), inkrement),
"verwenden": (aktor, figur) => verwenden(auspacken(aktor), figur),
"exportieren": (aktor) => ({"art": art, "angaben": exportieren(auspacken(aktor))}),
"importieren": (roh) => einpacken(art, importieren(roh)),
}
;
}
}
;
/**
* @author kcf <vidofnir@folksprak.org>
*/
function erzeuger_erstellen
(
richtung : typ_richtung
)
: typ_erzeuger
{
return {
"richtung": richtung,
};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function erzeuger_erstellen_aktor
(
richtung : typ_richtung
)
: typ_aktor
{
return {"art": "erzeuger", "angaben": erzeuger_erstellen(richtung)};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function erzeuger_beispiel
(
)
: typ_erzeuger
{
return erzeuger_erstellen(0);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function erzeuger_richtung_lesen
(
erzeuger : typ_erzeuger
)
: typ_richtung
{
return erzeuger.richtung;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function erzeuger_drehen
(
erzeuger : typ_erzeuger,
inkrement : int = +1
)
: void
{
erzeuger.richtung = richtung_addieren(erzeuger.richtung, inkrement);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function erzeuger_verwenden
(
erzeuger : typ_erzeuger,
figur : typ_figur
)
: void
{
figur_bewegen(figur, erzeuger.richtung);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function erzeuger_exportieren
(
erzeuger : typ_erzeuger
)
: any
{
return {
"richtung": richtung_exportieren(erzeuger.richtung),
};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function erzeuger_importieren
(
roh : any
)
: typ_erzeuger
{
return (
erzeuger_erstellen
(
richtung_importieren(roh["richtung"])
)
);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
let wrap = (angaben => ({"art": "erzeuger", "angaben": angaben}));
let unwrap = (aktor => aktor.angaben);
implementierung_aktor["erzeuger"] =
{
"beispiel": () => wrap(erzeuger_beispiel()),
"drehen": (aktor, inkrement) => erzeuger_drehen(unwrap(aktor), inkrement),
"verwenden": (aktor, figur) => erzeuger_verwenden(unwrap(aktor), figur),
"exportieren": (aktor) => ({"art": "erzeuger", "angaben": erzeuger_exportieren(aktor.angaben)}),
"importieren": (roh) => wrap(erzeuger_importieren(roh)),
}
;
}

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

@ -16,211 +16,224 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
module mod_vtm_aufbau
module mod_vtm
{
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_leser =
export module mod_aufbau
{
"richtung": typ_richtung,
"symbol_links": typ_symbol,
"symbol_rechts": typ_symbol,
}
;
/**
* @author kcf <vidofnir@folksprak.org>
*/
function leser_erstellen
(
richtung : typ_richtung,
symbol_links : typ_symbol,
symbol_rechts : typ_symbol
)
: typ_leser
{
return {
"richtung": richtung,
"symbol_links": symbol_links,
"symbol_rechts": symbol_rechts,
};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function leser_erstellen_aktor
(
richtung : typ_richtung,
symbol_links : typ_symbol,
symbol_rechts : typ_symbol
)
: typ_aktor
{
return {"art": "leser", "angaben": leser_erstellen(richtung, symbol_links, symbol_rechts)};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function leser_beispiel
(
)
: typ_leser
{
return leser_erstellen(0, 0, 1);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function leser_richtung_lesen
(
leser : typ_leser
)
: typ_richtung
{
return leser.richtung;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function leser_symbol_links_lesen
(
leser : typ_leser
)
: typ_symbol
{
return leser.symbol_links;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function leser_symbol_rechts_lesen
(
leser : typ_leser
)
: typ_symbol
{
return leser.symbol_rechts;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function leser_drehen
(
leser : typ_leser,
inkrement : int = +1
)
: void
{
leser.richtung = richtung_addieren(leser.richtung, inkrement);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function leser_verwenden
(
leser : typ_leser,
figur : typ_figur
)
: void
{
let symbol_ : schnittstelle_fehlermonade<typ_symbol> = figur_lesen(figur);
let summand : typ_richtung;
if (symbol_.ist_schlicht())
export module mod_aktor_leser
{
let symbol : typ_symbol = symbol_.lesen();
if (symbol === leser.symbol_links)
/**
* @author kcf <vidofnir@folksprak.org>
*/
let art : string = "leser";
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_leser =
{
figur_schieben(figur);
summand = +2;
"richtung": mod_richtung.typ_richtung,
"symbol_links": mod_symbol.typ_symbol,
"symbol_rechts": mod_symbol.typ_symbol,
}
else if (symbol === leser.symbol_rechts)
;
/**
* @author kcf <vidofnir@folksprak.org>
*/
function erstellen
(
richtung : mod_richtung.typ_richtung,
symbol_links : mod_symbol.typ_symbol,
symbol_rechts : mod_symbol.typ_symbol
)
: typ_leser
{
figur_schieben(figur);
summand = -2;
return {
"richtung": richtung,
"symbol_links": symbol_links,
"symbol_rechts": symbol_rechts,
};
}
else
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function erstellen_aktor
(
richtung : mod_richtung.typ_richtung,
symbol_links : mod_symbol.typ_symbol,
symbol_rechts : mod_symbol.typ_symbol
)
: mod_aktor.typ_aktor
{
summand = 0;
return einpacken(art, erstellen(richtung, symbol_links, symbol_rechts));
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function beispiel
(
)
: typ_leser
{
return erstellen(0, 0, 1);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function richtung_lesen
(
leser : typ_leser
)
: mod_richtung.typ_richtung
{
return leser.richtung;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function symbol_links_lesen
(
leser : typ_leser
)
: mod_symbol.typ_symbol
{
return leser.symbol_links;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function symbol_rechts_lesen
(
leser : typ_leser
)
: mod_symbol.typ_symbol
{
return leser.symbol_rechts;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function drehen
(
leser : typ_leser,
inkrement : int = +1
)
: void
{
leser.richtung = mod_richtung.addieren(leser.richtung, inkrement);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function verwenden
(
leser : typ_leser,
figur : mod_figur.typ_figur
)
: void
{
let symbol_ : schnittstelle_fehlermonade<mod_symbol.typ_symbol> = mod_figur.lesen(figur);
let summand : mod_richtung.typ_richtung;
if (symbol_.ist_schlicht())
{
let symbol : mod_symbol.typ_symbol = symbol_.lesen();
if (symbol === leser.symbol_links)
{
mod_figur.schieben(figur);
summand = +2;
}
else if (symbol === leser.symbol_rechts)
{
mod_figur.schieben(figur);
summand = -2;
}
else
{
summand = 0;
}
}
else
{
summand = 0;
}
let richtung : mod_richtung.typ_richtung = mod_richtung.addieren(leser.richtung, summand);
mod_figur.bewegen(figur, richtung);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function exportieren
(
leser : typ_leser
)
: any
{
return {
"richtung": mod_richtung.exportieren(leser.richtung),
"symbol_links": mod_symbol.exportieren(leser.symbol_links),
"symbol_rechts": mod_symbol.exportieren(leser.symbol_rechts),
};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function importieren
(
roh : any
)
: typ_leser
{
return (
erstellen
(
mod_richtung.importieren(roh["richtung"]),
mod_symbol.importieren(roh["symbol_links"]),
mod_symbol.importieren(roh["symbol_rechts"])
)
);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
mod_aktor.implementierung_aktor[art] =
{
"beispiel": () => einpacken(art, beispiel()),
"drehen": (aktor, inkrement) => drehen(auspacken(aktor), inkrement),
"verwenden": (aktor, figur) => verwenden(auspacken(aktor), figur),
"exportieren": (aktor) => ({"art": "leser", "angaben": exportieren(aktor.angaben)}),
"importieren": (roh) => einpacken(art, importieren(roh)),
}
;
}
else
{
summand = 0;
}
let richtung : typ_richtung = richtung_addieren(leser.richtung, summand);
figur_bewegen(figur, richtung);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function leser_exportieren
(
leser : typ_leser
)
: any
{
return {
"richtung": richtung_exportieren(leser.richtung),
"symbol_links": symbol_exportieren(leser.symbol_links),
"symbol_rechts": symbol_exportieren(leser.symbol_rechts),
};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function leser_importieren
(
roh : any
)
: typ_leser
{
return (
leser_erstellen
(
richtung_importieren(roh["richtung"]),
symbol_importieren(roh["symbol_links"]),
symbol_importieren(roh["symbol_rechts"])
)
);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
let wrap = (angaben => ({"art": "leser", "angaben": angaben}));
let unwrap = (aktor => aktor.angaben);
implementierung_aktor["leser"] =
{
"beispiel": () => wrap(leser_beispiel()),
"drehen": (aktor, inkrement) => leser_drehen(unwrap(aktor), inkrement),
"verwenden": (aktor, figur) => leser_verwenden(unwrap(aktor), figur),
"exportieren": (aktor) => ({"art": "leser", "angaben": leser_exportieren(aktor.angaben)}),
"importieren": (roh) => wrap(leser_importieren(roh)),
}
;
}

329
quelldatein/aufbau/aktoren/schreiber.ts
View file

@ -16,168 +16,181 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
module mod_vtm_aufbau
module mod_vtm
{
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_schreiber =
export module mod_aufbau
{
richtung : typ_richtung;
symbol : typ_symbol;
export module mod_aktor_schreiber
{
/**
* @author kcf <vidofnir@folksprak.org>
*/
let art : string = "schreiber";
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_schreiber =
{
richtung : mod_richtung.typ_richtung;
symbol : mod_symbol.typ_symbol;
}
;
/**
* @author kcf <vidofnir@folksprak.org>
*/
function erstellen
(
richtung : mod_richtung.typ_richtung,
symbol : mod_symbol.typ_symbol
)
: typ_schreiber
{
return {
"richtung": richtung,
"symbol": symbol,
};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function erstellen_aktor
(
richtung : mod_richtung.typ_richtung,
symbol : mod_symbol.typ_symbol
)
: mod_aktor.typ_aktor
{
return einpacken(art, erstellen(richtung, symbol));
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function beispiel
(
)
: typ_schreiber
{
return erstellen(0, 0);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function richtung_lesen
(
schreiber : typ_schreiber
)
: mod_richtung.typ_richtung
{
return schreiber.richtung;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function symbol_lesen
(
schreiber : typ_schreiber
)
: mod_symbol.typ_symbol
{
return schreiber.symbol;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function drehen
(
schreiber : typ_schreiber,
inkrement : int = +1
)
: void
{
schreiber.richtung = mod_richtung.addieren(schreiber.richtung, inkrement);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function verwenden
(
schreiber : typ_schreiber,
figur : mod_figur.typ_figur
)
: void
{
mod_figur.schreiben(figur, schreiber.symbol);
mod_figur.bewegen(figur, schreiber.richtung);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function exportieren
(
schreiber : typ_schreiber
)
: any
{
return {
"richtung": mod_richtung.exportieren(schreiber.richtung),
"symbol": mod_symbol.exportieren(schreiber.symbol),
};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function importieren
(
roh : any
)
: typ_schreiber
{
return (
erstellen
(
mod_richtung.importieren(roh["richtung"]),
mod_symbol.importieren(roh["symbol"])
)
);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
mod_aktor.implementierung_aktor["schreiber"] =
{
"beispiel": () => einpacken(art, beispiel()),
"drehen": (aktor, inkrement) => drehen(auspacken(aktor), inkrement),
"verwenden": (aktor, figur) => verwenden(auspacken(aktor), figur),
"exportieren": (aktor) => ({"art": "schreiber", "angaben": exportieren(aktor.angaben)}),
"importieren": (roh) => einpacken(art, importieren(roh)),
}
;
}
}
;
/**
* @author kcf <vidofnir@folksprak.org>
*/
function schreiber_erstellen
(
richtung : typ_richtung,
symbol : typ_symbol
)
: typ_schreiber
{
return {
"richtung": richtung,
"symbol": symbol,
};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function schreiber_erstellen_aktor
(
richtung : typ_richtung,
symbol : typ_symbol
)
: typ_aktor
{
return {"art": "schreiber", "angaben": schreiber_erstellen(richtung, symbol)};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function schreiber_beispiel
(
)
: typ_schreiber
{
return schreiber_erstellen(0, 0);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function schreiber_richtung_lesen
(
schreiber : typ_schreiber
)
: typ_richtung
{
return schreiber.richtung;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function schreiber_symbol_lesen
(
schreiber : typ_schreiber
)
: typ_symbol
{
return schreiber.symbol;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function schreiber_drehen
(
schreiber : typ_schreiber,
inkrement : int = +1
)
: void
{
schreiber.richtung = richtung_addieren(schreiber.richtung, inkrement);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function schreiber_verwenden
(
schreiber : typ_schreiber,
figur : typ_figur
)
: void
{
figur_schreiben(figur, schreiber.symbol);
figur_bewegen(figur, schreiber.richtung);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function schreiber_exportieren
(
schreiber : typ_schreiber
)
: any
{
return {
"richtung": richtung_exportieren(schreiber.richtung),
"symbol": symbol_exportieren(schreiber.symbol),
};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function schreiber_importieren
(
roh : any
)
: typ_schreiber
{
return (
schreiber_erstellen
(
richtung_importieren(roh["richtung"]),
symbol_importieren(roh["symbol"])
)
);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
let wrap = (angaben => ({"art": "schreiber", "angaben": angaben}));
let unwrap = (aktor => aktor.angaben);
implementierung_aktor["schreiber"] =
{
"beispiel": () => wrap(schreiber_beispiel()),
"drehen": (aktor, inkrement) => schreiber_drehen(unwrap(aktor), inkrement),
"verwenden": (aktor, figur) => schreiber_verwenden(unwrap(aktor), figur),
"exportieren": (aktor) => ({"art": "schreiber", "angaben": schreiber_exportieren(aktor.angaben)}),
"importieren": (roh) => wrap(schreiber_importieren(roh)),
}
;
}

249
quelldatein/aufbau/aktoren/verwerfer.ts
View file

@ -16,128 +16,141 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
module mod_vtm_aufbau
module mod_vtm
{
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_verwerfer =
export module mod_aufbau
{
export module mod_aktor_verwerfer
{
/**
* @author kcf <vidofnir@folksprak.org>
*/
let art : string = "verwerfer";
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_verwerfer =
{
}
;
/**
* @author kcf <vidofnir@folksprak.org>
*/
function erstellen
(
)
: typ_verwerfer
{
return {
};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function erstellen_aktor
(
)
: mod_aktor.typ_aktor
{
return einpacken(art, erstellen());
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function beispiel
(
)
: typ_verwerfer
{
return erstellen();
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function drehen
(
verwerfer : typ_verwerfer,
inkrement ?: int
)
: void
{
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function verwenden
(
verwerfer : typ_verwerfer,
figur : mod_figur.typ_figur
)
: void
{
mod_figur.verwerfen(figur);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function exportieren
(
verwerfer : typ_verwerfer
)
: any
{
return {
};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function importieren
(
roh : any
)
: typ_verwerfer
{
return (
erstellen
(
)
);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
mod_aktor.implementierung_aktor[art] =
{
"beispiel": () => einpacken(art, beispiel()),
"drehen": (aktor, inkrement) => drehen(auspacken(aktor), inkrement),
"verwenden": (aktor, figur) => verwenden(auspacken(aktor), figur),
"exportieren": (aktor) => ({"art": art, "angaben": exportieren(aktor.angaben)}),
"importieren": (roh) => einpacken(art, importieren(roh)),
}
;
}
}
;
/**
* @author kcf <vidofnir@folksprak.org>
*/
function verwerfer_erstellen
(
)
: typ_verwerfer
{
return {
};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function verwerfer_erstellen_aktor
(
)
: typ_aktor
{
return {"art": "verwerfer", "angaben": verwerfer_erstellen()};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function verwerfer_beispiel
(
)
: typ_verwerfer
{
return verwerfer_erstellen();
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function verwerfer_drehen
(
verwerfer : typ_verwerfer,
inkrement ?: int
)
: void
{
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function verwerfer_verwenden
(
verwerfer : typ_verwerfer,
figur : typ_figur
)
: void
{
figur_verwerfen(figur);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function verwerfer_exportieren
(
verwerfer : typ_verwerfer
)
: any
{
return {
};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function verwerfer_importieren
(
roh : any
)
: typ_verwerfer
{
return (
verwerfer_erstellen
(
)
);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
let wrap = (angaben => ({"art": "verwerfer", "angaben": angaben}));
let unwrap = (aktor => aktor.angaben);
implementierung_aktor["verwerfer"] =
{
"beispiel": () => wrap(verwerfer_beispiel()),
"drehen": (aktor, inkrement) => verwerfer_drehen(unwrap(aktor), inkrement),
"verwenden": (aktor, figur) => verwerfer_verwenden(unwrap(aktor), figur),
"exportieren": (aktor) => ({"art": "verwerfer", "angaben": verwerfer_exportieren(aktor.angaben)}),
"importieren": (roh) => wrap(verwerfer_importieren(roh)),
}
;
}

8
quelldatein/aufbau/aufgaben/akzeptortest.ts
View file

@ -24,7 +24,7 @@ module mod_vtm_aufbau
*/
export type typ_akzeptortest =
{
eingabe : Array<typ_symbol>;
eingabe : Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>;
annehmen : boolean;
}
;
@ -35,7 +35,7 @@ module mod_vtm_aufbau
*/
export function akzeptortest_erstellen
(
eingabe : Array<typ_symbol>,
eingabe : Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>,
annehmen : boolean
)
: typ_akzeptortest
@ -54,7 +54,7 @@ module mod_vtm_aufbau
(
akzeptortest : typ_akzeptortest
)
: Array<typ_symbol>
: Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>
{
return akzeptortest.eingabe;
}
@ -67,7 +67,7 @@ module mod_vtm_aufbau
(
akzeptortest : typ_akzeptortest,
angenommen : boolean,
ausgabe : Array<typ_symbol>
ausgabe : Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>
)
: boolean
{

6
quelldatein/aufbau/aufgaben/test.ts
View file

@ -32,10 +32,10 @@ module mod_vtm_aufbau
(
test : typ_test
)
: Array<typ_symbol>
: Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>
{
return (
fallunterscheidung<Array<typ_symbol>>
fallunterscheidung<Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>>
(
test,
{
@ -54,7 +54,7 @@ module mod_vtm_aufbau
(
test : typ_test,
angenommen : boolean,
ausgabe : Array<typ_symbol>
ausgabe : Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>
)
: boolean
{

14
quelldatein/aufbau/aufgaben/transduktortest.ts
View file

@ -24,8 +24,8 @@ module mod_vtm_aufbau
*/
export type typ_transduktortest =
{
eingabe : Array<typ_symbol>;
ausgabe : Array<typ_symbol>;
eingabe : Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>;
ausgabe : Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>;
}
;
@ -35,8 +35,8 @@ module mod_vtm_aufbau
*/
export function transduktortest_erstellen
(
eingabe : Array<typ_symbol>,
ausgabe : Array<typ_symbol>
eingabe : Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>,
ausgabe : Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>
)
: typ_transduktortest
{
@ -54,7 +54,7 @@ module mod_vtm_aufbau
(
transduktortest : typ_transduktortest
)
: Array<typ_symbol>
: Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>
{
return transduktortest.eingabe;
}
@ -67,7 +67,7 @@ module mod_vtm_aufbau
(
transduktortest : typ_transduktortest,
angenommen : boolean,
ausgabe : Array<typ_symbol>
ausgabe : Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>
)
: boolean
{
@ -80,7 +80,7 @@ module mod_vtm_aufbau
let gleich : boolean = true;
for (let index : int = 0; index < transduktortest.ausgabe.length; index += 1)
{
if (! symbol_vergleichen(transduktortest.ausgabe[index], ausgabe[index]))
if (! mod_vtm.mod_aufbau.mod_symbol.vergleichen(transduktortest.ausgabe[index], ausgabe[index]))
{
gleich = false;
break;

332
quelldatein/aufbau/figur.ts
View file

@ -3,184 +3,194 @@
* 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 export function figur_License as published by
* 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 export function figur_License for more details.
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General export function figur_License
* 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 mod_vtm_aufbau
module mod_vtm
{
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_figur =
export module mod_aufbau
{
zustand : typ_zustand;
band : Array<typ_symbol>;
stelle : typ_stelle;
}
;
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function figur_erstellen
(
band : Array<typ_symbol> = [],
stelle : typ_stelle = stelle_null()
)
: typ_figur
{
return {
"zustand": zustand_laufend,
"band": band,
"stelle": stelle,
};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function figur_zustand_lesen
(
figur : typ_figur
)
: typ_zustand
{
return figur.zustand;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function figur_band_lesen
(
figur : typ_figur
)
: Array<typ_symbol>
{
return figur.band;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function figur_stelle_lesen
(
figur : typ_figur
)
: typ_stelle
{
return figur.stelle;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function figur_bewegen
(
figur : typ_figur,
richtung : typ_richtung
)
: void
{
let summand : typ_stelle = stelle_von_richtung(richtung);
figur.stelle = stelle_addieren(figur.stelle, summand);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function figur_schreiben
(
figur : typ_figur,
symbol : typ_symbol
)
: void
{
figur.band.push(symbol);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function figur_lesen
(
figur : typ_figur
)
: schnittstelle_fehlermonade<typ_symbol>
{
if (figur.band.length <= 0)
export module mod_figur
{
return (new klasse_nichts<typ_symbol>());
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_figur =
{
zustand : mod_zustand.typ_zustand;
band : Array<mod_symbol.typ_symbol>;
stelle : mod_stelle.typ_stelle;
}
;
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function erstellen
(
band : Array<mod_symbol.typ_symbol> = [],
stelle : mod_stelle.typ_stelle = mod_stelle.null_()
)
: typ_figur
{
return {
"zustand": mod_zustand.laufend,
"band": band,
"stelle": stelle,
};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function zustand_lesen
(
figur : typ_figur
)
: mod_zustand.typ_zustand
{
return figur.zustand;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function band_lesen
(
figur : typ_figur
)
: Array<mod_symbol.typ_symbol>
{
return figur.band;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function stelle_lesen
(
figur : typ_figur
)
: mod_stelle.typ_stelle
{
return figur.stelle;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function bewegen
(
figur : typ_figur,
richtung : mod_richtung.typ_richtung
)
: void
{
let summand : mod_stelle.typ_stelle = mod_stelle.von_richtung(richtung);
figur.stelle = mod_stelle.addieren(figur.stelle, summand);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function schreiben
(
figur : typ_figur,
symbol : mod_symbol.typ_symbol
)
: void
{
figur.band.push(symbol);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function lesen
(
figur : typ_figur
)
: schnittstelle_fehlermonade<mod_symbol.typ_symbol>
{
if (figur.band.length <= 0)
{
return (new klasse_nichts<mod_symbol.typ_symbol>());
}
else
{
return (new klasse_schlicht<mod_symbol.typ_symbol>(figur.band[0]));
}
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function schieben
(
figur : typ_figur
)
: void
{
if (figur.band.length <= 0)
{
let meldung : string = "Band ist leer";
throw (new Error(meldung));
}
else
{
figur.band.shift();
}
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function annehmen
(
figur : typ_figur
)
: void
{
figur.zustand = mod_zustand.angenommen;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function verwerfen
(
figur : typ_figur
)
: void
{
figur.zustand = mod_zustand.abgelehnt;
}
}
else
{
return (new klasse_schlicht<typ_symbol>(figur.band[0]));
}
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function figur_schieben
(
figur : typ_figur
)
: void
{
if (figur.band.length <= 0)
{
let meldung : string = "Band ist leer";
throw (new Error(meldung));
}
else
{
figur.band.shift();
}
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function figur_annehmen
(
figur : typ_figur
)
: void
{
figur.zustand = zustand_angenommen;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function figur_verwerfen
(
figur : typ_figur
)
: void
{
figur.zustand = zustand_abgelehnt;
}
}

34
quelldatein/aufbau/modus.ts
View file

@ -16,22 +16,32 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
module mod_vtm_aufbau
module mod_vtm
{
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_modus = int;
export module mod_aufbau
{
export module mod_modus
{
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_modus = int;
/**
* @author kcf <vidofnir@folksprak.org>
*/
export const modus_initial = 0;
export const modus_ungewiss = 1;
export const modus_fehlerhaft = 2;
export const modus_korrekt = 3;
/**
* @author kcf <vidofnir@folksprak.org>
*/
export const initial = 0;
export const ungewiss = 1;
export const fehlerhaft = 2;
export const korrekt = 3;
}
}
}

632
quelldatein/aufbau/partie.ts
View file

@ -3,356 +3,366 @@
* 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 export function partie_License as published by
* 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 export function partie_License for more details.
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General export function partie_License
* 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 mod_vtm_aufbau
module mod_vtm
{
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_partie =
export module mod_aufbau
{
welt : typ_welt;
figur : schnittstelle_fehlermonade<typ_figur>;
aufgabe : typ_aufgabe;
testindex : schnittstelle_fehlermonade<int>;
modus : typ_modus;
lauscher : {[ereignis : string] : Array<(angaben ?: any)=>void>};
}
;
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function partie_erstellen
(
aufgabe : typ_aufgabe
)
: typ_partie
{
let partie : typ_partie = {
"welt": undefined,
"figur": undefined,
"aufgabe": aufgabe,
"testindex": undefined,
"modus": undefined,
"lauscher": undefined,
};
partie.lauscher = {
"aenderung_aufgabe": [],
"aenderung_welt": [],
"aenderung_figur": [],
"aenderung_modus": [],
};
partie_welt_leeren(partie, false);
partie_zuruecksetzen(partie, false);
return partie;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function partie_lauschen(partie : typ_partie, ereignis : string, prozedur : (angaben ?: any)=>void) : void
{
if (ereignis in partie.lauscher)
export module mod_partie
{
partie.lauscher[ereignis].push(prozedur);
}
else
{
let meldung : string = "kein Ereignis mit diesem Name";
throw (new Error(meldung));
}
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function partie_benachrichtigen(partie : typ_partie, ereignis : string, angaben : any = {}) : void
{
if (ereignis in partie.lauscher)
{
partie.lauscher[ereignis].forEach
(
prozedur =>
{
prozedur(angaben);
}
)
;
}
else
{
let meldung : string = "kein Ereignis mit diesem Name";
throw (new Error(meldung));
}
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function partie_zuruecksetzen(partie : typ_partie, bescheid_geben : boolean = true) : void
{
partie.figur = (new klasse_nichts<typ_figur>());
partie.testindex = (new klasse_nichts<int>());
partie.modus = modus_initial;
if (bescheid_geben)
{
partie_benachrichtigen(partie, "aenderung_figur", {});
partie_benachrichtigen(partie, "aenderung_modus", {});
}
else
{
// nichts tun
}
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function partie_aufgabe_lesen(partie : typ_partie) : typ_aufgabe
{
return partie.aufgabe;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function partie_aufgabe_setzen(partie : typ_partie, aufgabe : typ_aufgabe) : void
{
partie.aufgabe = aufgabe;
// partie.welt_leeren();
partie_benachrichtigen(partie, "aenderung_aufgabe", {});
partie_zuruecksetzen(partie);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function partie_welt_lesen(partie : typ_partie) : typ_welt
{
return partie.welt;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function partie_welt_setzen(partie : typ_partie, welt : mod_vtm_aufbau.typ_welt, bescheid_geben : boolean = true) : void
{
partie.welt = welt;
if (bescheid_geben)
{
partie_benachrichtigen(partie, "aenderung_welt", {});
}
else
{
// nichts tun
}
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function partie_welt_leeren(partie : typ_partie, bescheid_geben : boolean = true) : void
{
partie.welt = welt_blanko();
if (bescheid_geben)
{
partie_benachrichtigen(partie, "aenderung_welt", {});
}
else
{
// nichts tun
}
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function partie_figur_lesen(partie : typ_partie) : schnittstelle_fehlermonade<typ_figur>
{
return partie.figur;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function partie_modus_lesen(partie : typ_partie) : typ_modus
{
return partie.modus;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function partie_welt_feld_wechseln(partie : typ_partie, stelle : typ_stelle, umgekehrt : boolean = false) : void
{
if (! (partie.modus === mod_vtm_aufbau.modus_initial))
{
let meldung : string = "gesperrt";
}
else
{
welt_feld_wechseln(partie.welt, stelle, umgekehrt);
partie_benachrichtigen
(
partie,
"aenderung_welt",
{
"art": "feld_wechseln",
"angaben":
{
"stelle": stelle,
"umgekehrt": umgekehrt,
"feld": welt_feld_holen(partie.welt, stelle),
}
}
)
;
}
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function partie_welt_feld_drehen(partie : typ_partie, stelle : typ_stelle, inkrement : int = +1) : void
{
if (! (partie.modus === mod_vtm_aufbau.modus_initial))
{
let meldung : string = "gesperrt";
}
else
{
welt_feld_drehen(partie.welt, stelle, inkrement);
partie_benachrichtigen(partie, "aenderung_welt", {});
}
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function partie_fortfahren(partie : typ_partie) : void
{
switch (partie.modus)
{
case modus_initial:
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_partie =
{
partie.modus = modus_ungewiss;
partie.testindex = (new klasse_schlicht<int>(0));
partie_benachrichtigen(partie, "aenderung_modus", {});
break;
welt : mod_welt.typ_welt;
figur : schnittstelle_fehlermonade<mod_figur.typ_figur>;
aufgabe : mod_vtm_aufbau.typ_aufgabe;
testindex : schnittstelle_fehlermonade<int>;
modus : mod_modus.typ_modus;
lauscher : {[ereignis : string] : Array<(angaben ?: any)=>void>};
}
case modus_ungewiss:
;
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function erstellen
(
aufgabe : mod_vtm_aufbau.typ_aufgabe
)
: typ_partie
{
if (! partie.figur.ist_schlicht())
let partie : typ_partie = {
"welt": undefined,
"figur": undefined,
"aufgabe": aufgabe,
"testindex": undefined,
"modus": undefined,
"lauscher": undefined,
};
partie.lauscher = {
"aenderung_aufgabe": [],
"aenderung_welt": [],
"aenderung_figur": [],
"aenderung_modus": [],
};
welt_leeren(partie, false);
zuruecksetzen(partie, false);
return partie;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function lauschen(partie : typ_partie, ereignis : string, prozedur : (angaben ?: any)=>void) : void
{
if (ereignis in partie.lauscher)
{
let test : typ_test = aufgabe_tests(partie.aufgabe)[partie.testindex.lesen()];
let band : Array<typ_symbol> = mod_vtm_helfer.liste_kopieren<typ_symbol>(test_eingabe(test));
let stelle : typ_stelle = welt_erzeuger_finden(partie.welt);
partie.figur = (
new klasse_schlicht<typ_figur>
(
figur_erstellen
(
band,
stelle
)
)
);
partie.lauscher[ereignis].push(prozedur);
}
else
{
let figur : typ_figur = partie.figur.lesen();
let stelle : typ_stelle = figur_stelle_lesen(figur);
let aktor_ : schnittstelle_fehlermonade<typ_aktor> = welt_feld_holen(partie.welt, stelle);
let aktor : typ_aktor = (aktor_.ist_schlicht() ? aktor_.lesen() : verwerfer_erstellen_aktor());
aktor_verwenden(aktor, figur);
let zustand : typ_zustand = figur_zustand_lesen(figur);
if (zustand === zustand_laufend)
{
// nichts tun
}
else if ((zustand === zustand_angenommen) || (zustand === zustand_abgelehnt))
{
let angenommen : boolean = (zustand === zustand_angenommen);
let ausgabe : Array<typ_symbol> = figur_band_lesen(figur);
partie.figur = (new klasse_nichts<typ_figur>());
let testindex : int = partie.testindex.lesen();
let tests : Array<typ_test> = aufgabe_tests(partie.aufgabe);
let test : typ_test = tests[testindex];
if (! test_pruefen(test, angenommen, ausgabe))
let meldung : string = "kein Ereignis mit diesem Name";
throw (new Error(meldung));
}
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function benachrichtigen(partie : typ_partie, ereignis : string, angaben : any = {}) : void
{
if (ereignis in partie.lauscher)
{
partie.lauscher[ereignis].forEach
(
prozedur =>
{
partie.modus = modus_fehlerhaft;
partie_benachrichtigen(partie, "aenderung_modus", {});
prozedur(angaben);
}
)
;
}
else
{
let meldung : string = "kein Ereignis mit diesem Name";
throw (new Error(meldung));
}
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
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.modus = mod_modus.initial;
if (bescheid_geben)
{
benachrichtigen(partie, "aenderung_figur", {});
benachrichtigen(partie, "aenderung_modus", {});
}
else
{
// nichts tun
}
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function aufgabe_lesen(partie : typ_partie) : mod_vtm_aufbau.typ_aufgabe
{
return partie.aufgabe;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function aufgabe_setzen(partie : typ_partie, aufgabe : mod_vtm_aufbau.typ_aufgabe) : void
{
partie.aufgabe = aufgabe;
// partie.welt_leeren();
benachrichtigen(partie, "aenderung_aufgabe", {});
zuruecksetzen(partie);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function welt_lesen(partie : typ_partie) : mod_welt.typ_welt
{
return partie.welt;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function welt_setzen(partie : typ_partie, welt : mod_welt.typ_welt, bescheid_geben : boolean = true) : void
{
partie.welt = welt;
if (bescheid_geben)
{
benachrichtigen(partie, "aenderung_welt", {});
}
else
{
// nichts tun
}
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function welt_leeren(partie : typ_partie, bescheid_geben : boolean = true) : void
{
partie.welt = mod_welt.blanko();
if (bescheid_geben)
{
benachrichtigen(partie, "aenderung_welt", {});
}
else
{
// nichts tun
}
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function figur_lesen(partie : typ_partie) : schnittstelle_fehlermonade<mod_figur.typ_figur>
{
return partie.figur;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function modus_lesen(partie : typ_partie) : mod_modus.typ_modus
{
return partie.modus;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function welt_feld_wechseln(partie : typ_partie, stelle : mod_stelle.typ_stelle, umgekehrt : boolean = false) : void
{
if (! (partie.modus === mod_modus.initial))
{
let meldung : string = "gesperrt";
}
else
{
mod_welt.feld_wechseln(partie.welt, stelle, umgekehrt);
benachrichtigen
(
partie,
"aenderung_welt",
{
"art": "feld_wechseln",
"angaben":
{
"stelle": stelle,
"umgekehrt": umgekehrt,
"feld": mod_welt.feld_holen(partie.welt, stelle),
}
}
)
;
}
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function welt_feld_drehen(partie : typ_partie, stelle : mod_stelle.typ_stelle, inkrement : int = +1) : void
{
if (! (partie.modus === mod_modus.initial))
{
let meldung : string = "gesperrt";
}
else
{
mod_welt.feld_drehen(partie.welt, stelle, inkrement);
benachrichtigen(partie, "aenderung_welt", {});
}
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function fortfahren(partie : typ_partie) : void
{
switch (partie.modus)
{
case mod_modus.initial:
{
partie.modus = mod_modus.ungewiss;
partie.testindex = (new klasse_schlicht<int>(0));
benachrichtigen(partie, "aenderung_modus", {});
break;
}
case mod_modus.ungewiss:
{
if (! partie.figur.ist_schlicht())
{
let test : mod_vtm_aufbau.typ_test = mod_vtm_aufbau.aufgabe_tests(partie.aufgabe)[partie.testindex.lesen()];
let band : Array<mod_symbol.typ_symbol> = mod_vtm_helfer.liste_kopieren<mod_symbol.typ_symbol>(mod_vtm_aufbau.test_eingabe(test));
let stelle : mod_stelle.typ_stelle = mod_welt.erzeuger_finden(partie.welt);
partie.figur = (
new klasse_schlicht<mod_figur.typ_figur>
(
mod_figur.erstellen
(
band,
stelle
)
)
);
}
else
{
testindex += 1;
if (testindex < tests.length)
let figur : mod_figur.typ_figur = partie.figur.lesen();
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());
mod_aktor.verwenden(aktor, figur);
let zustand : mod_zustand.typ_zustand = mod_figur.zustand_lesen(figur);
if (zustand === mod_zustand.laufend)
{
// nächsten Test auswählen
partie.testindex = (new klasse_schlicht<int>(testindex));
// nichts tun
}
else if ((zustand === mod_zustand.angenommen) || (zustand === mod_zustand.abgelehnt))
{
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();
let tests : Array<mod_vtm_aufbau.typ_test> = mod_vtm_aufbau.aufgabe_tests(partie.aufgabe);
let test : mod_vtm_aufbau.typ_test = tests[testindex];
if (! mod_vtm_aufbau.test_pruefen(test, angenommen, ausgabe))
{
partie.modus = mod_modus.fehlerhaft;
benachrichtigen(partie, "aenderung_modus", {});
}
else
{
testindex += 1;
if (testindex < tests.length)
{
// nächsten Test auswählen
partie.testindex = (new klasse_schlicht<int>(testindex));
}
else
{
// auf Modus "korrekt" wechseln
partie.testindex = (new klasse_nichts<int>());
partie.modus = mod_modus.korrekt;
benachrichtigen(partie, "aenderung_modus", {});
}
}
}
else
{
// auf Modus "korrekt" wechseln
partie.testindex = (new klasse_nichts<int>());
partie.modus = modus_korrekt;
partie_benachrichtigen(partie, "aenderung_modus", {});
let meldung : string = "unbehandelter Zustand";
throw (new Error(meldung));
}
}
benachrichtigen(partie, "aenderung_figur", {});
break;
}
else
case mod_modus.fehlerhaft:
{
let meldung : string = "unbehandelter Zustand";
// nichts tun
break;
}
case mod_modus.korrekt:
{
// nichts tun
break;
}
default:
{
let meldung : string = "unbehandelter Modus";
throw (new Error(meldung));
break;
}
}
partie_benachrichtigen(partie, "aenderung_figur", {});
break;
}
case modus_fehlerhaft:
{
// nichts tun
break;
}
case modus_korrekt:
{
// nichts tun
break;
}
default:
{
let meldung : string = "unbehandelter Modus";
throw (new Error(meldung));
break;
}
}
}

71
quelldatein/aufbau/richtung.ts
View file

@ -16,40 +16,49 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
module mod_vtm_aufbau
module mod_vtm
{
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_richtung = int;
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function richtung_addieren(richtung1 : typ_richtung, richtung2 : typ_richtung) : typ_richtung
export module mod_aufbau
{
return mod_vtm_helfer.mod(richtung1 + richtung2, 6);
export module mod_richtung
{
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_richtung = int;
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function addieren(richtung1 : typ_richtung, richtung2 : typ_richtung) : typ_richtung
{
return mod_vtm_helfer.mod(richtung1 + richtung2, 6);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function exportieren(richtung : typ_richtung) : int
{
return richtung;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function importieren(richtung_ : int) : typ_richtung
{
return richtung_;
}
}
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function richtung_exportieren(richtung : typ_richtung) : int
{
return richtung;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function richtung_importieren(richtung_ : int) : typ_richtung
{
return richtung_;
}
}

157
quelldatein/aufbau/stelle.ts
View file

@ -16,86 +16,95 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
module mod_vtm_aufbau
module mod_vtm
{
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_stelle = {u : int; v : int;};
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function stelle_hash(stelle : typ_stelle) : string
export module mod_aufbau
{
return (stelle.u.toFixed(0) + "_" + stelle.v.toFixed(0));
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function stelle_von_hash(hash : string) : typ_stelle
{
let teile : Array<string> = hash.split("_");
return {"u": parseInt(teile[0]), "v": parseInt(teile[1])};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function stelle_null() : typ_stelle
{
return {"u": 0, "v": 0};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function stelle_von_richtung(richtung : typ_richtung) : typ_stelle
{
switch (richtung)
export module mod_stelle
{
case 0: {return {"u": +1, "v": 0}; break;}
case 1: {return {"u": +1, "v": +1}; break;}
case 2: {return {"u": 0, "v": +1}; break;}
case 3: {return {"u": -1, "v": 0}; break;}
case 4: {return {"u": -1, "v": -1}; break;}
case 5: {return {"u": 0, "v": -1}; break;}
default: {throw (new Error("ungültige Richtung '" + String(richtung) + "'")); break;}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_stelle = {u : int; v : int;};
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function hash(stelle : typ_stelle) : string
{
return (stelle.u.toFixed(0) + "_" + stelle.v.toFixed(0));
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function von_hash(hash : string) : typ_stelle
{
let teile : Array<string> = hash.split("_");
return {"u": parseInt(teile[0]), "v": parseInt(teile[1])};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function null_() : typ_stelle
{
return {"u": 0, "v": 0};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function von_richtung(richtung : mod_richtung.typ_richtung) : typ_stelle
{
switch (richtung)
{
case 0: {return {"u": +1, "v": 0}; break;}
case 1: {return {"u": +1, "v": +1}; break;}
case 2: {return {"u": 0, "v": +1}; break;}
case 3: {return {"u": -1, "v": 0}; break;}
case 4: {return {"u": -1, "v": -1}; break;}
case 5: {return {"u": 0, "v": -1}; break;}
default: {throw (new Error("ungültige Richtung '" + String(richtung) + "'")); break;}
}
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function addieren(stelle1 : typ_stelle, stelle2 : typ_stelle) : typ_stelle
{
return {"u": (stelle1.u + stelle2.u), "v": (stelle1.v + stelle2.v)};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function exportieren(stelle : typ_stelle) : string
{
return hash(stelle);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function importieren(stelle_ : string) : typ_stelle
{
return von_hash(stelle_);
}
}
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function stelle_addieren(stelle1 : typ_stelle, stelle2 : typ_stelle) : typ_stelle
{
return {"u": (stelle1.u + stelle2.u), "v": (stelle1.v + stelle2.v)};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function stelle_exportieren(stelle : typ_stelle) : string
{
return stelle_hash(stelle);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function stelle_importieren(stelle_ : string) : typ_stelle
{
return stelle_von_hash(stelle_);
}
}

62
quelldatein/aufbau/symbol.ts
View file

@ -16,39 +16,49 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
module mod_vtm_aufbau
module mod_vtm
{
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_symbol = int;
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function symbol_vergleichen(symbol1 : typ_symbol, symbol2 : typ_symbol) : boolean
export module mod_aufbau
{
return (symbol1 === symbol2);
}
export module mod_symbol
{
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_symbol = int;
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function symbol_exportieren(symbol : typ_symbol) : int
{
return symbol;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function vergleichen(symbol1 : typ_symbol, symbol2 : typ_symbol) : boolean
{
return (symbol1 === symbol2);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function symbol_importieren(symbol_ : int) : typ_symbol
{
return symbol_;
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function exportieren(symbol : typ_symbol) : int
{
return symbol;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function importieren(symbol_ : int) : typ_symbol
{
return symbol_;
}
}
}
}

598
quelldatein/aufbau/welt.ts
View file

@ -3,343 +3,353 @@
* 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 export function welt_License as published by
* 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 export function welt_License for more details.
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General export function welt_License
* 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 mod_vtm_aufbau
module mod_vtm
{
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_welt =
export module mod_aufbau
{
felder : mod_vtm_helfer.klasse_hashmap<typ_stelle, typ_aktor>;
}
;
export module mod_welt
{
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_welt =
{
felder : mod_vtm_helfer.klasse_hashmap<mod_stelle.typ_stelle, mod_aktor.typ_aktor>;
}
;
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function welt_erstellen
(
felder : mod_vtm_helfer.klasse_hashmap<typ_stelle, typ_aktor> = (new mod_vtm_helfer.klasse_hashmap<typ_stelle, typ_aktor>(stelle_hash))
)
: typ_welt
{
return {
"felder": felder,
};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
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))
)
: typ_welt
{
return {
"felder": felder,
};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function welt_felder_lesen(welt : typ_welt) : Array<{stelle : typ_stelle; aktor : typ_aktor;}>
{
let felder : Array<{stelle : typ_stelle; aktor : typ_aktor;}> = [];
welt.felder.iterieren
(
(stelle, aktor) => felder.push({"stelle": stelle, "aktor": aktor})
)
;
return felder;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function welt_feld_holen(welt : typ_welt, stelle : typ_stelle) : schnittstelle_fehlermonade<typ_aktor>
{
return welt.felder.holen(stelle);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function welt_feld_setzen(welt : typ_welt, stelle : typ_stelle, aktor : typ_aktor) : void
{
welt.felder.setzen(stelle, aktor);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function welt_feld_wechseln(welt : typ_welt, stelle : typ_stelle, umgekehrt : boolean = false) : void
{
let erweitert : boolean = true;
let liste : Array<{pruefer : (aktor : typ_aktor)=>boolean; ersteller : ()=>typ_aktor;}> = (
[]
.concat
(
[
{
"pruefer": (aktor) => (aktor.art === "befoerderer"),
"ersteller": () => befoerderer_erstellen_aktor(0),
},
]
)
.concat
(
mod_vtm_helfer.sequenz(erweitert ? 4 : 2).map
(
symbol => (
{
"pruefer": (aktor) =>
{
if (aktor.art === "schreiber")
{
return (schreiber_symbol_lesen(aktor.angaben) === symbol);
}
else
{
return false;
}
}
,
"ersteller": () => schreiber_erstellen_aktor(0, symbol)
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
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
(
(stelle, aktor) => felder.push({"stelle": stelle, "aktor": aktor})
)
)
)
.concat
(
mod_vtm_helfer.sequenz(erweitert ? 2 : 1).map
(
index =>
{
let symbol_links : typ_symbol = (2*index+0);
let symbol_rechts : typ_symbol = (2*index+1);
return (
;
return felder;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function feld_holen(welt : typ_welt, stelle : mod_stelle.typ_stelle) : schnittstelle_fehlermonade<mod_aktor.typ_aktor>
{
return welt.felder.holen(stelle);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function feld_setzen(welt : typ_welt, stelle : mod_stelle.typ_stelle, aktor : mod_aktor.typ_aktor) : void
{
welt.felder.setzen(stelle, aktor);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function feld_wechseln(welt : typ_welt, stelle : mod_stelle.typ_stelle, umgekehrt : boolean = false) : void
{
let erweitert : boolean = true;
let liste : Array<{pruefer : (aktor : mod_aktor.typ_aktor)=>boolean; ersteller : ()=>mod_aktor.typ_aktor;}> = (
[]
.concat
(
[
{
"pruefer": (aktor) =>
"pruefer": (aktor) => (aktor.art === "befoerderer"),
"ersteller": () => mod_aktor_befoerderer.erstellen_aktor(0),
},
]
)
.concat
(
mod_vtm_helfer.sequenz(erweitert ? 4 : 2).map
(
symbol => (
{
if (aktor.art === "leser")
"pruefer": (aktor) =>
{
return (
(leser_symbol_links_lesen(aktor.angaben) === symbol_links)
&&
(leser_symbol_rechts_lesen(aktor.angaben) === symbol_rechts)
);
if (aktor.art === "schreiber")
{
return (mod_aktor_schreiber.symbol_lesen(aktor.angaben) === symbol);
}
else
{
return false;
}
}
,
"ersteller": () => mod_aktor_schreiber.erstellen_aktor(0, symbol)
}
)
)
)
.concat
(
mod_vtm_helfer.sequenz(erweitert ? 2 : 1).map
(
index =>
{
let symbol_links : mod_symbol.typ_symbol = (2*index+0);
let symbol_rechts : mod_symbol.typ_symbol = (2*index+1);
return (
{
"pruefer": (aktor) =>
{
if (aktor.art === "leser")
{
return (
(mod_aktor_leser.symbol_links_lesen(aktor.angaben) === symbol_links)
&&
(mod_aktor_leser.symbol_rechts_lesen(aktor.angaben) === symbol_rechts)
);
}
else
{
return false;
}
}
,
"ersteller": () => mod_aktor_leser.erstellen_aktor(0, symbol_links, symbol_rechts)
}
);
}
)
)
.concat
(
[
{
"pruefer": (aktor) => (aktor.art === "verwerfer"),
"ersteller": () => mod_aktor_verwerfer.erstellen_aktor(),
},
]
)
);
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 aktor_alt : mod_aktor.typ_aktor = aktor_alt_.lesen();
let gefunden : boolean = (
liste.some
(
(eintrag, index) =>
{
if (eintrag.pruefer(aktor_alt))
{
index_alt = (new klasse_schlicht<int>(index));
return true;
}
else
{
return false;
}
}
,
"ersteller": () => leser_erstellen_aktor(0, symbol_links, symbol_rechts)
}
);
}
)
)
.concat
(
[
{
"pruefer": (aktor) => (aktor.art === "verwerfer"),
"ersteller": () => verwerfer_erstellen_aktor(),
},
]
)
);
let index_alt : schnittstelle_fehlermonade<int>;
let aktor_alt_ : schnittstelle_fehlermonade<typ_aktor> = welt.felder.holen(stelle);
if (aktor_alt_.ist_schlicht())
{
let aktor_alt : typ_aktor = aktor_alt_.lesen();
let gefunden : boolean = (
liste.some
(
(eintrag, index) =>
{
if (eintrag.pruefer(aktor_alt))
{
index_alt = (new klasse_schlicht<int>(index));
return true;
}
else
{
return false;
}
}
)
);
if (! gefunden)
{
index_alt = (new klasse_nichts<int>());
}
else
{
// nichts tun
}
}
else
{
let meldung : string = "kein Aktor gesetzt";
// console.warn(meldung);
index_alt = (new klasse_schlicht<int>(0));
}
if (index_alt.ist_schlicht())
{
let index_neu : int = mod_vtm_helfer.mod(index_alt.lesen() + (umgekehrt ? -1 : +1), liste.length);
let aktor_neu : typ_aktor = liste[index_neu].ersteller();
welt_feld_setzen(welt, stelle, aktor_neu);
}
else
{
let meldung : string = ("Aktor nicht gefunden");
// throw (new Error(meldung));
console.warn(meldung);
}
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function welt_feld_drehen(welt : typ_welt, stelle : typ_stelle, inkrement : int = +1) : void
{
let aktor_ : schnittstelle_fehlermonade<typ_aktor> = welt.felder.holen(stelle);
if (aktor_.ist_schlicht)
{
aktor_drehen(aktor_.lesen(), inkrement);
}
else
{
console.warn("kein Aktor gesetzt");
}
}
/**
* @author kcf <vidofnir@folksprak.org>
* @throws {Error}
*/
export function welt_erzeuger_finden(welt : typ_welt) : typ_stelle
{
let stelle : schnittstelle_fehlermonade<typ_stelle> = (new klasse_nichts<typ_stelle>());
welt.felder.iterieren
(
(stelle_, aktor) =>
{
if (aktor.art === "erzeuger")
{
if (stelle.ist_schlicht())
)
);
if (! gefunden)
{
let meldung : string = "mehrere Erzeuger gefunden";
throw (new Error(meldung));
index_alt = (new klasse_nichts<int>());
}
else
{
stelle = (new klasse_schlicht<typ_stelle>(stelle_));
// nichts tun
}
}
}
)
;
if (stelle.ist_schlicht())
{
return stelle.lesen();
}
else
{
let meldung : string = "kein Erzeuger gefunden";
throw (new Error(meldung));
}
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function welt_blanko(groesse : int = 3) : typ_welt
{
let welt : typ_welt = welt_erstellen();
for (let u : int = -groesse; u <= +groesse; u += 1)
{
for (let v : int = -groesse; v <= +groesse; v += 1)
{
if (Math.abs(u-v) <= groesse)
else
{
let stelle : typ_stelle = {"u": u, "v": v};
let aktor : typ_aktor;
if ((u === -groesse) && (v === 0))
{
aktor = erzeuger_erstellen_aktor(0);
}
else if ((u === +groesse) && (v === 0))
{
aktor = annehmer_erstellen_aktor();
}
else
{
aktor = verwerfer_erstellen_aktor();
}
welt.felder.setzen(stelle, aktor);
let meldung : string = "kein Aktor gesetzt";
// console.warn(meldung);
index_alt = (new klasse_schlicht<int>(0));
}
if (index_alt.ist_schlicht())
{
let index_neu : int = mod_vtm_helfer.mod(index_alt.lesen() + (umgekehrt ? -1 : +1), liste.length);
let aktor_neu : mod_aktor.typ_aktor = liste[index_neu].ersteller();
feld_setzen(welt, stelle, aktor_neu);
}
else
{
let meldung : string = ("Aktor nicht gefunden");
// throw (new Error(meldung));
console.warn(meldung);
}
}
}
return welt;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function welt_exportieren(welt : typ_welt) : any
{
let roh : any = {};
roh["felder"] = {};
welt.felder.iterieren
(
(stelle, aktor) =>
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function feld_drehen(welt : typ_welt, stelle : mod_stelle.typ_stelle, inkrement : int = +1) : void
{
let stelle_ : string = stelle_exportieren(stelle);
let aktor_ : any = aktor_exportieren(aktor);
roh["felder"][stelle_] = aktor_;
let aktor_ : schnittstelle_fehlermonade<mod_aktor.typ_aktor> = welt.felder.holen(stelle);
if (aktor_.ist_schlicht)
{
mod_aktor.drehen(aktor_.lesen(), inkrement);
}
else
{
console.warn("kein Aktor gesetzt");
}
}
)
;
return roh;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function welt_importieren(roh : any) : typ_welt
{
let felder : mod_vtm_helfer.klasse_hashmap<typ_stelle, typ_aktor> = (new mod_vtm_helfer.klasse_hashmap<typ_stelle, typ_aktor>(stelle_hash));
for (let stelle_ in roh["felder"])
{
let stelle : typ_stelle = stelle_importieren(stelle_);
let aktor_ : typ_aktor = roh["felder"][stelle_];
let aktor : typ_aktor = aktor_importieren(aktor_);
felder.setzen(stelle, aktor);
/**
* @author kcf <vidofnir@folksprak.org>
* @throws {Error}
*/
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
(
(stelle_, aktor) =>
{
if (aktor.art === "erzeuger")
{
if (stelle.ist_schlicht())
{
let meldung : string = "mehrere Erzeuger gefunden";
throw (new Error(meldung));
}
else
{
stelle = (new klasse_schlicht<mod_stelle.typ_stelle>(stelle_));
}
}
}
)
;
if (stelle.ist_schlicht())
{
return stelle.lesen();
}
else
{
let meldung : string = "kein Erzeuger gefunden";
throw (new Error(meldung));
}
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function blanko(groesse : int = 3) : typ_welt
{
let welt : typ_welt = erstellen();
for (let u : int = -groesse; u <= +groesse; u += 1)
{
for (let v : int = -groesse; v <= +groesse; v += 1)
{
if (Math.abs(u-v) <= groesse)
{
let stelle : mod_stelle.typ_stelle = {"u": u, "v": v};
let aktor : mod_aktor.typ_aktor;
if ((u === -groesse) && (v === 0))
{
aktor = mod_aktor_erzeuger.erstellen_aktor(0);
}
else if ((u === +groesse) && (v === 0))
{
aktor = mod_aktor_annehmer.erstellen_aktor();
}
else
{
aktor = mod_aktor_verwerfer.erstellen_aktor();
}
welt.felder.setzen(stelle, aktor);
}
}
}
return welt;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function exportieren(welt : typ_welt) : any
{
let roh : any = {};
roh["felder"] = {};
welt.felder.iterieren
(
(stelle, aktor) =>
{
let stelle_ : string = mod_stelle.exportieren(stelle);
let aktor_ : any = mod_aktor.exportieren(aktor);
roh["felder"][stelle_] = aktor_;
}
)
;
return roh;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
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));
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);
}
return (
erstellen
(
felder
)
);
}
}
return (
welt_erstellen
(
felder
)
);
}
}

32
quelldatein/aufbau/zustand.ts
View file

@ -16,21 +16,31 @@
* along with this program. If not, see <https://www.gnu.org/licenses/>.
*/
module mod_vtm_aufbau
module mod_vtm
{
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_zustand = int;
export module mod_aufbau
{
export module mod_zustand
{
/**
* @author kcf <vidofnir@folksprak.org>
*/
export type typ_zustand = int;
/**
* @author kcf <vidofnir@folksprak.org>
*/
export var zustand_abgelehnt = -1;
export var zustand_laufend = 0;
export var zustand_angenommen = +1;
/**
* @author kcf <vidofnir@folksprak.org>
*/
export var abgelehnt = -1;
export var laufend = 0;
export var angenommen = +1;
}
}
}

18
quelldatein/basis/aufruf.ts
View file

@ -22,6 +22,24 @@
type typ_komplex<typ_angaben> = {art : string; angaben ?: typ_angaben;};
/**
* @author kcf <vidofnir@folksprak.org>
*/
function einpacken<typ_angaben>(art : string, angaben : typ_angaben) : typ_komplex<typ_angaben>
{
return {"art": art, "angaben": angaben};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function auspacken<typ_angaben>(komplex : typ_komplex<typ_angaben>) : typ_angaben
{
return komplex.angaben;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/

21
quelldatein/haupt.ts
View file

@ -115,27 +115,27 @@ function haupt() : void
let hoehe : float = 80;
[
{
"aufbau": mod_vtm_aufbau.aktor_beispiel("erzeuger"),
"aufbau": mod_vtm.mod_aufbau.mod_aktor.beispiel("erzeuger"),
"bereich": document.querySelector("#hilfe_aktoren_aktor_erzeuger"),
},
{
"aufbau": mod_vtm_aufbau.aktor_beispiel("annehmer"),
"aufbau": mod_vtm.mod_aufbau.mod_aktor.beispiel("annehmer"),
"bereich": document.querySelector("#hilfe_aktoren_aktor_annehmer"),
},
{
"aufbau": mod_vtm_aufbau.aktor_beispiel("verwerfer"),
"aufbau": mod_vtm.mod_aufbau.mod_aktor.beispiel("verwerfer"),
"bereich": document.querySelector("#hilfe_aktoren_aktor_verwerfer"),
},
{
"aufbau": mod_vtm_aufbau.aktor_beispiel("befoerderer"),
"aufbau": mod_vtm.mod_aufbau.mod_aktor.beispiel("befoerderer"),
"bereich": document.querySelector("#hilfe_aktoren_aktor_befoerderer"),
},
{
"aufbau": mod_vtm_aufbau.aktor_beispiel("schreiber"),
"aufbau": mod_vtm.mod_aufbau.mod_aktor.beispiel("schreiber"),
"bereich": document.querySelector("#hilfe_aktoren_aktor_schreiber"),
},
{
"aufbau": mod_vtm_aufbau.aktor_beispiel("leser"),
"aufbau": mod_vtm.mod_aufbau.mod_aktor.beispiel("leser"),
"bereich": document.querySelector("#hilfe_aktoren_aktor_leser"),
},
]
@ -147,7 +147,7 @@ function haupt() : void
mod_vtm_manifestation.svg_aktor_erstellen_manifestation
(
eintrag.aufbau,
mod_vtm_aufbau.stelle_null()
mod_vtm.mod_aufbau.mod_stelle.null_()
)
);
let xmlknoten : mod_vtm_helfer.typ_xmlknoten = (
@ -168,13 +168,13 @@ function haupt() : void
}
// Spiel
{
// let aufbau : mod_vtm_aufbau.typ_partie;
let aufbau : mod_vtm.mod_aufbau.mod_partie.typ_partie;
aufgaben_eintragen
(
function (aufgabe : mod_vtm_aufbau.typ_aufgabe) : void {mod_vtm_aufbau.partie_aufgabe_setzen(aufbau, aufgabe);}
function (aufgabe : mod_vtm_aufbau.typ_aufgabe) : void {mod_vtm.mod_aufbau.mod_partie.aufgabe_setzen(aufbau, aufgabe);}
)
;
aufbau = mod_vtm_aufbau.partie_erstellen(mod_vtm_aufbau.aufgabe_holen(0));
aufbau = mod_vtm.mod_aufbau.mod_partie.erstellen(mod_vtm_aufbau.aufgabe_holen(0));
mod_vtm_manifestation.manifestation_einrichten
(
mod_vtm_manifestation.web_partie_erstellen_erweitert
@ -194,7 +194,6 @@ function haupt() : void
;
}
}
var aufbau : mod_vtm_aufbau.typ_partie = null;
/**