From 3193117543820517fbc8d713b91042d512e6c1ea Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Christian=20Fra=C3=9F?= Date: Wed, 28 Mar 2018 13:59:29 +0200 Subject: [PATCH] save --- quelldatein/aufbau/aktoren/_aktor.ts | 44 +-- quelldatein/aufbau/aktoren/annehmer.ts | 64 ++-- quelldatein/aufbau/aktoren/befoerderer.ts | 84 ++--- quelldatein/aufbau/aktoren/erzeuger.ts | 86 ++--- quelldatein/aufbau/aktoren/leser.ts | 132 +++---- quelldatein/aufbau/aktoren/schreiber.ts | 104 +++--- quelldatein/aufbau/aktoren/verwerfer.ts | 64 ++-- .../aufbau/aufgaben/akzeptoraufgabe.ts | 32 +- quelldatein/aufbau/aufgaben/akzeptortest.ts | 38 +- quelldatein/aufbau/aufgaben/aufgabe.ts | 120 +++---- quelldatein/aufbau/aufgaben/test.ts | 60 ++-- .../aufbau/aufgaben/transduktoraufgabe.ts | 32 +- .../aufbau/aufgaben/transduktortest.ts | 44 +-- quelldatein/aufbau/figur.ts | 104 +++--- quelldatein/aufbau/modus.ts | 12 +- quelldatein/aufbau/partie.ts | 336 +++++++++--------- quelldatein/aufbau/richtung.ts | 18 +- quelldatein/aufbau/stelle.ts | 32 +- quelldatein/aufbau/symbol.ts | 10 +- quelldatein/aufbau/welt.ts | 234 ++++++------ quelldatein/aufbau/zustand.ts | 12 +- quelldatein/daten.ts | 20 +- quelldatein/daten/aufgaben.dat.js | 184 +++++----- quelldatein/daten/zeichenketten/de.dat.js | 96 ++--- quelldatein/daten/zeichenketten/en.dat.js | 96 ++--- quelldatein/haupt.ts | 120 +++---- quelldatein/helfer/aufruf.ts | 38 +- quelldatein/helfer/brauch.ts | 40 +-- quelldatein/helfer/fehlermonade.ts | 66 ++-- quelldatein/helfer/hashmap.ts | 58 +-- quelldatein/helfer/mathematik.ts | 2 +- quelldatein/helfer/uebersetzung.ts | 100 +++--- quelldatein/helfer/vektor.ts | 16 +- quelldatein/helfer/verschiedenes.ts | 6 +- quelldatein/helfer/xml.ts | 88 ++--- quelldatein/manifestation/manifestation.ts | 32 +- quelldatein/manifestation/position.ts | 14 +- quelldatein/manifestation/speicher/partie.ts | 102 +++--- quelldatein/manifestation/svg/_svg.ts | 42 +-- quelldatein/manifestation/svg/aktor/_aktor.ts | 76 ++-- .../manifestation/svg/aktor/annehmer.ts | 24 +- .../manifestation/svg/aktor/befoerderer.ts | 22 +- .../manifestation/svg/aktor/erzeuger.ts | 22 +- quelldatein/manifestation/svg/aktor/leser.ts | 42 +-- .../manifestation/svg/aktor/schreiber.ts | 22 +- .../manifestation/svg/aktor/verwerfer.ts | 24 +- quelldatein/manifestation/svg/figur.ts | 106 +++--- quelldatein/manifestation/svg/partie.ts | 90 ++--- quelldatein/manifestation/web/partie.ts | 292 +++++++-------- quelldatein/manifestation/web/vtm.html | 132 +++---- quelldatein/manifestation/web/vtm.scss | 86 ++--- 51 files changed, 1866 insertions(+), 1854 deletions(-) diff --git a/quelldatein/aufbau/aktoren/_aktor.ts b/quelldatein/aufbau/aktoren/_aktor.ts index a372573..ae82d95 100644 --- a/quelldatein/aufbau/aktoren/_aktor.ts +++ b/quelldatein/aufbau/aktoren/_aktor.ts @@ -19,28 +19,28 @@ module mod_vtm { - export module mod_aufbau + export module mod_model { - export module mod_aktor + export module mod_actuator { /** * @author kcf */ - export type typ_aktor = lib_aufruf.typ_komplex; + export type type_actuator = lib_call.type_complex; /** * @author kcf */ - export type signatur_aktor = + export type signature_actuator = { - 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; + example : ()=>type_actuator; + rotate : (actuator : type_actuator, inkrement : int)=>void; + use : (actuator : type_actuator, token : mod_token.type_token)=>void; + export : (actuator : type_actuator)=>any; + import : (raw : any)=>type_actuator; } ; @@ -48,16 +48,16 @@ module mod_vtm /** * @author kcf */ - export var brauch_aktor : lib_brauch.typ_brauch = lib_brauch.erstellen(); + export var trait_actuator : lib_trait.type_trait = lib_trait.create(); /** * @author kcf */ /* - export function erstellen(art : string, kern : any) : typ_aktor + export function create(kind : string, kern : any) : type_actuator { - return lib_aufruf.einpacken(art, kern); + return lib_call.wrap(kind, kern); } */ @@ -65,45 +65,45 @@ module mod_vtm /** * @author kcf */ - export function beispiel(art : string) : typ_aktor + export function example(kind : string) : type_actuator { - return lib_brauch.anwenden(brauch_aktor, art)["beispiel"](); + return lib_trait.deploy(trait_actuator, kind)["example"](); } /** * @author kcf */ - export function drehen(aktor : typ_aktor, inkrement ?: int) : void + export function rotate(actuator : type_actuator, inkrement ?: int) : void { - return lib_brauch.anwenden(brauch_aktor, aktor.art)["drehen"](aktor, inkrement); + return lib_trait.deploy(trait_actuator, actuator.kind)["rotate"](actuator, inkrement); } /** * @author kcf */ - export function verwenden(aktor : typ_aktor, figur : mod_figur.typ_figur) : void + export function use(actuator : type_actuator, token : mod_token.type_token) : void { - return lib_brauch.anwenden(brauch_aktor, aktor.art)["verwenden"](aktor, figur); + return lib_trait.deploy(trait_actuator, actuator.kind)["use"](actuator, token); } /** * @author kcf */ - export function exportieren(aktor : typ_aktor) : any + export function export_(actuator : type_actuator) : any { - return lib_brauch.anwenden(brauch_aktor, aktor.art)["exportieren"](aktor); + return lib_trait.deploy(trait_actuator, actuator.kind)["export"](actuator); } /** * @author kcf */ - export function importieren(roh : any) : typ_aktor + export function import_(raw : any) : type_actuator { - return lib_brauch.anwenden(brauch_aktor, roh.art)["importieren"](roh); + return lib_trait.deploy(trait_actuator, raw.kind)["import"](raw); } } diff --git a/quelldatein/aufbau/aktoren/annehmer.ts b/quelldatein/aufbau/aktoren/annehmer.ts index 0783e5a..577fec3 100644 --- a/quelldatein/aufbau/aktoren/annehmer.ts +++ b/quelldatein/aufbau/aktoren/annehmer.ts @@ -19,10 +19,10 @@ module mod_vtm { - export module mod_aufbau + export module mod_model { - export module mod_aktor + export module mod_actuator { export module mod_annehmer @@ -31,13 +31,13 @@ module mod_vtm /** * @author kcf */ - let art : string = "annehmer"; + let kind : string = "annehmer"; /** * @author kcf */ - export type typ_annehmer = + export type type_annehmer = { } ; @@ -46,10 +46,10 @@ module mod_vtm /** * @author kcf */ - function erstellen + function create ( ) - : typ_annehmer + : type_annehmer { return { }; @@ -59,33 +59,33 @@ module mod_vtm /** * @author kcf */ - export function erstellen_aktor + export function create_actuator ( ) - : mod_aktor.typ_aktor + : mod_actuator.type_actuator { - return lib_aufruf.einpacken(art, erstellen()); + return lib_call.wrap(kind, create()); } /** * @author kcf */ - function beispiel + function example ( ) - : typ_annehmer + : type_annehmer { - return erstellen(); + return create(); } /** * @author kcf */ - function drehen + function rotate ( - annehmer : typ_annehmer, + annehmer : type_annehmer, inkrement ?: int ) : void @@ -96,23 +96,23 @@ module mod_vtm /** * @author kcf */ - function verwenden + function use ( - annehmer : typ_annehmer, - figur : mod_figur.typ_figur + annehmer : type_annehmer, + token : mod_token.type_token ) : void { - mod_figur.annehmen(figur); + mod_token.accept(token); } /** * @author kcf */ - function exportieren + function export_ ( - annehmer : typ_annehmer + annehmer : type_annehmer ) : any { @@ -124,14 +124,14 @@ module mod_vtm /** * @author kcf */ - function importieren + function import_ ( - roh : any + raw : any ) - : typ_annehmer + : type_annehmer { return ( - erstellen + create ( ) ); @@ -141,16 +141,16 @@ module mod_vtm /** * @author kcf */ - lib_brauch.umsetzen + lib_trait.attend ( - brauch_aktor, - art, + trait_actuator, + kind, { - "beispiel": () => lib_aufruf.einpacken(art, beispiel()), - "drehen": (aktor, inkrement) => drehen(lib_aufruf.auspacken(aktor), inkrement), - "verwenden": (aktor, figur) => verwenden(lib_aufruf.auspacken(aktor), figur), - "exportieren": (aktor) => ({"art": art, "angaben": exportieren(aktor.angaben)}), - "importieren": (roh) => lib_aufruf.einpacken(art, importieren(roh["angaben"])), + "example": () => lib_call.wrap(kind, example()), + "rotate": (actuator, inkrement) => rotate(lib_call.unwrap(actuator), inkrement), + "use": (actuator, token) => use(lib_call.unwrap(actuator), token), + "export": (actuator) => ({"kind": kind, "data": export_(actuator.data)}), + "import": (raw) => lib_call.wrap(kind, import_(raw["data"])), } ) ; diff --git a/quelldatein/aufbau/aktoren/befoerderer.ts b/quelldatein/aufbau/aktoren/befoerderer.ts index d4a91db..5b3c20e 100644 --- a/quelldatein/aufbau/aktoren/befoerderer.ts +++ b/quelldatein/aufbau/aktoren/befoerderer.ts @@ -19,10 +19,10 @@ module mod_vtm { - export module mod_aufbau + export module mod_model { - export module mod_aktor + export module mod_actuator { export module mod_befoerderer @@ -31,15 +31,15 @@ module mod_vtm /** * @author kcf */ - let art : string = "befoerderer"; + let kind : string = "befoerderer"; /** * @author kcf */ - export type typ_befoerderer = + export type type_befoerderer = { - richtung : mod_richtung.typ_richtung; + direction : mod_direction.type_direction; } ; @@ -47,14 +47,14 @@ module mod_vtm /** * @author kcf */ - function erstellen + function create ( - richtung : mod_richtung.typ_richtung + direction : mod_direction.type_direction ) - : typ_befoerderer + : type_befoerderer { return { - "richtung": richtung, + "direction": direction, }; } @@ -62,80 +62,80 @@ module mod_vtm /** * @author kcf */ - export function erstellen_aktor + export function create_actuator ( - richtung : mod_richtung.typ_richtung + direction : mod_direction.type_direction ) - : mod_aktor.typ_aktor + : mod_actuator.type_actuator { - return lib_aufruf.einpacken(art, erstellen(richtung)); + return lib_call.wrap(kind, create(direction)); } /** * @author kcf */ - function beispiel + function example ( ) - : typ_befoerderer + : type_befoerderer { - return erstellen(0); + return create(0); } /** * @author kcf */ - export function richtung_lesen + export function direction_read ( - befoerderer : typ_befoerderer + befoerderer : type_befoerderer ) - : mod_richtung.typ_richtung + : mod_direction.type_direction { - return befoerderer.richtung; + return befoerderer.direction; } /** * @author kcf */ - function drehen + function rotate ( - befoerderer : typ_befoerderer, + befoerderer : type_befoerderer, inkrement : int = +1 ) : void { - befoerderer.richtung = mod_richtung.addieren(befoerderer.richtung, inkrement); + befoerderer.direction = mod_direction.add(befoerderer.direction, inkrement); } /** * @author kcf */ - function verwenden + function use ( - befoerderer : typ_befoerderer, - figur : mod_figur.typ_figur + befoerderer : type_befoerderer, + token : mod_token.type_token ) : void { - mod_figur.bewegen(figur, befoerderer.richtung); + mod_token.move(token, befoerderer.direction); } /** * @author kcf */ - function exportieren + function export_ ( - befoerderer : typ_befoerderer + befoerderer : type_befoerderer ) : any { return { - "richtung": mod_richtung.exportieren(befoerderer.richtung), + "direction": mod_direction.export_(befoerderer.direction), }; } @@ -143,16 +143,16 @@ module mod_vtm /** * @author kcf */ - function importieren + function import_ ( befoerderer_ : any ) - : typ_befoerderer + : type_befoerderer { return ( - erstellen + create ( - mod_richtung.importieren(befoerderer_["richtung"]) + mod_direction.import_(befoerderer_["direction"]) ) ); } @@ -161,16 +161,16 @@ module mod_vtm /** * @author kcf */ - lib_brauch.umsetzen + lib_trait.attend ( - brauch_aktor, - art, + trait_actuator, + kind, { - "beispiel": () => lib_aufruf.einpacken(art, beispiel()), - "drehen": (aktor, inkrement) => drehen(lib_aufruf.auspacken(aktor), inkrement), - "verwenden": (aktor, figur) => verwenden(lib_aufruf.auspacken(aktor), figur), - "exportieren": (aktor) => ({"art": art, "angaben": exportieren(aktor.angaben)}), - "importieren": (roh) => lib_aufruf.einpacken(art, importieren(roh["angaben"])), + "example": () => lib_call.wrap(kind, example()), + "rotate": (actuator, inkrement) => rotate(lib_call.unwrap(actuator), inkrement), + "use": (actuator, token) => use(lib_call.unwrap(actuator), token), + "export": (actuator) => ({"kind": kind, "data": export_(actuator.data)}), + "import": (raw) => lib_call.wrap(kind, import_(raw["data"])), } ) ; diff --git a/quelldatein/aufbau/aktoren/erzeuger.ts b/quelldatein/aufbau/aktoren/erzeuger.ts index 135f3e5..19ee196 100644 --- a/quelldatein/aufbau/aktoren/erzeuger.ts +++ b/quelldatein/aufbau/aktoren/erzeuger.ts @@ -19,10 +19,10 @@ module mod_vtm { - export module mod_aufbau + export module mod_model { - export module mod_aktor + export module mod_actuator { export module mod_erzeuger @@ -31,15 +31,15 @@ module mod_vtm /** * @author kcf */ - let art : string = "erzeuger"; + let kind : string = "erzeuger"; /** * @author kcf */ - export type typ_erzeuger = + export type type_erzeuger = { - richtung : mod_richtung.typ_richtung; + direction : mod_direction.type_direction; } ; @@ -47,14 +47,14 @@ module mod_vtm /** * @author kcf */ - function erstellen + function create ( - richtung : mod_richtung.typ_richtung + direction : mod_direction.type_direction ) - : typ_erzeuger + : type_erzeuger { return { - "richtung": richtung, + "direction": direction, }; } @@ -62,80 +62,80 @@ module mod_vtm /** * @author kcf */ - export function erstellen_aktor + export function create_actuator ( - richtung : mod_richtung.typ_richtung + direction : mod_direction.type_direction ) - : mod_aktor.typ_aktor + : mod_actuator.type_actuator { - return lib_aufruf.einpacken(art, erstellen(richtung)); + return lib_call.wrap(kind, create(direction)); } /** * @author kcf */ - function beispiel + function example ( ) - : typ_erzeuger + : type_erzeuger { - return erstellen(0); + return create(0); } /** * @author kcf */ - export function richtung_lesen + export function direction_read ( - erzeuger : typ_erzeuger + erzeuger : type_erzeuger ) - : mod_richtung.typ_richtung + : mod_direction.type_direction { - return erzeuger.richtung; + return erzeuger.direction; } /** * @author kcf */ - function drehen + function rotate ( - erzeuger : typ_erzeuger, + erzeuger : type_erzeuger, inkrement : int = +1 ) : void { - erzeuger.richtung = mod_richtung.addieren(erzeuger.richtung, inkrement); + erzeuger.direction = mod_direction.add(erzeuger.direction, inkrement); } /** * @author kcf */ - function verwenden + function use ( - erzeuger : typ_erzeuger, - figur : mod_figur.typ_figur + erzeuger : type_erzeuger, + token : mod_token.type_token ) : void { - mod_figur.bewegen(figur, erzeuger.richtung); + mod_token.move(token, erzeuger.direction); } /** * @author kcf */ - function exportieren + function export_ ( - erzeuger : typ_erzeuger + erzeuger : type_erzeuger ) : any { return { - "richtung": mod_richtung.exportieren(erzeuger.richtung), + "direction": mod_direction.export_(erzeuger.direction), }; } @@ -143,16 +143,16 @@ module mod_vtm /** * @author kcf */ - function importieren + function import_ ( - roh : any + raw : any ) - : typ_erzeuger + : type_erzeuger { return ( - erstellen + create ( - mod_richtung.importieren(roh["richtung"]) + mod_direction.import_(raw["direction"]) ) ); } @@ -161,16 +161,16 @@ module mod_vtm /** * @author kcf */ - lib_brauch.umsetzen + lib_trait.attend ( - brauch_aktor, - art, + trait_actuator, + kind, { - "beispiel": () => lib_aufruf.einpacken(art, beispiel()), - "drehen": (aktor, inkrement) => drehen(lib_aufruf.auspacken(aktor), inkrement), - "verwenden": (aktor, figur) => verwenden(lib_aufruf.auspacken(aktor), figur), - "exportieren": (aktor) => ({"art": art, "angaben": exportieren(aktor.angaben)}), - "importieren": (roh) => lib_aufruf.einpacken(art, importieren(roh["angaben"])), + "example": () => lib_call.wrap(kind, example()), + "rotate": (actuator, inkrement) => rotate(lib_call.unwrap(actuator), inkrement), + "use": (actuator, token) => use(lib_call.unwrap(actuator), token), + "export": (actuator) => ({"kind": kind, "data": export_(actuator.data)}), + "import": (raw) => lib_call.wrap(kind, import_(raw["data"])), } ) ; diff --git a/quelldatein/aufbau/aktoren/leser.ts b/quelldatein/aufbau/aktoren/leser.ts index 37cb942..60a9f71 100644 --- a/quelldatein/aufbau/aktoren/leser.ts +++ b/quelldatein/aufbau/aktoren/leser.ts @@ -19,10 +19,10 @@ module mod_vtm { - export module mod_aufbau + export module mod_model { - export module mod_aktor + export module mod_actuator { export module mod_leser @@ -31,17 +31,17 @@ module mod_vtm /** * @author kcf */ - let art : string = "leser"; + let kind : string = "leser"; /** * @author kcf */ - export type typ_leser = + export type type_leser = { - "richtung": mod_richtung.typ_richtung, - "symbol_links": mod_symbol.typ_symbol, - "symbol_rechts": mod_symbol.typ_symbol, + "direction": mod_direction.type_direction, + "symbol_links": mod_symbol.type_symbol, + "symbol_rechts": mod_symbol.type_symbol, } ; @@ -49,16 +49,16 @@ module mod_vtm /** * @author kcf */ - function erstellen + function create ( - richtung : mod_richtung.typ_richtung, - symbol_links : mod_symbol.typ_symbol, - symbol_rechts : mod_symbol.typ_symbol + direction : mod_direction.type_direction, + symbol_links : mod_symbol.type_symbol, + symbol_rechts : mod_symbol.type_symbol ) - : typ_leser + : type_leser { return { - "richtung": richtung, + "direction": direction, "symbol_links": symbol_links, "symbol_rechts": symbol_rechts, }; @@ -68,51 +68,51 @@ module mod_vtm /** * @author kcf */ - export function erstellen_aktor + export function create_actuator ( - richtung : mod_richtung.typ_richtung, - symbol_links : mod_symbol.typ_symbol, - symbol_rechts : mod_symbol.typ_symbol + direction : mod_direction.type_direction, + symbol_links : mod_symbol.type_symbol, + symbol_rechts : mod_symbol.type_symbol ) - : mod_aktor.typ_aktor + : mod_actuator.type_actuator { - return lib_aufruf.einpacken(art, erstellen(richtung, symbol_links, symbol_rechts)); + return lib_call.wrap(kind, create(direction, symbol_links, symbol_rechts)); } /** * @author kcf */ - function beispiel + function example ( ) - : typ_leser + : type_leser { - return erstellen(0, 0, 1); + return create(0, 0, 1); } /** * @author kcf */ - export function richtung_lesen + export function direction_read ( - leser : typ_leser + leser : type_leser ) - : mod_richtung.typ_richtung + : mod_direction.type_direction { - return leser.richtung; + return leser.direction; } /** * @author kcf */ - export function symbol_links_lesen + export function symbol_links_read ( - leser : typ_leser + leser : type_leser ) - : mod_symbol.typ_symbol + : mod_symbol.type_symbol { return leser.symbol_links; } @@ -121,11 +121,11 @@ module mod_vtm /** * @author kcf */ - export function symbol_rechts_lesen + export function symbol_rechts_read ( - leser : typ_leser + leser : type_leser ) - : mod_symbol.typ_symbol + : mod_symbol.type_symbol { return leser.symbol_rechts; } @@ -134,40 +134,40 @@ module mod_vtm /** * @author kcf */ - function drehen + function rotate ( - leser : typ_leser, + leser : type_leser, inkrement : int = +1 ) : void { - leser.richtung = mod_richtung.addieren(leser.richtung, inkrement); + leser.direction = mod_direction.add(leser.direction, inkrement); } /** * @author kcf */ - function verwenden + function use ( - leser : typ_leser, - figur : mod_figur.typ_figur + leser : type_leser, + token : mod_token.type_token ) : void { - let symbol_ : lib_fehlermonade.typ_fehlermonade = mod_figur.lesen(figur); - let summand : mod_richtung.typ_richtung; - if (lib_fehlermonade.voll(symbol_)) + let symbol_ : lib_errormonade.type_errormonade = mod_token.read(token); + let summand : mod_direction.type_direction; + if (lib_errormonade.filled(symbol_)) { - let symbol : mod_symbol.typ_symbol = lib_fehlermonade.lesen(symbol_); + let symbol : mod_symbol.type_symbol = lib_errormonade.read(symbol_); if (symbol === leser.symbol_links) { - mod_figur.schieben(figur); + mod_token.shift(token); summand = +2; } else if (symbol === leser.symbol_rechts) { - mod_figur.schieben(figur); + mod_token.shift(token); summand = -2; } else @@ -179,24 +179,24 @@ module mod_vtm { summand = 0; } - let richtung : mod_richtung.typ_richtung = mod_richtung.addieren(leser.richtung, summand); - mod_figur.bewegen(figur, richtung); + let direction : mod_direction.type_direction = mod_direction.add(leser.direction, summand); + mod_token.move(token, direction); } /** * @author kcf */ - function exportieren + function export_ ( - leser : typ_leser + leser : type_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), + "direction": mod_direction.export_(leser.direction), + "symbol_links": mod_symbol.export_(leser.symbol_links), + "symbol_rechts": mod_symbol.export_(leser.symbol_rechts), }; } @@ -204,18 +204,18 @@ module mod_vtm /** * @author kcf */ - function importieren + function import_ ( - roh : any + raw : any ) - : typ_leser + : type_leser { return ( - erstellen + create ( - mod_richtung.importieren(roh["richtung"]), - mod_symbol.importieren(roh["symbol_links"]), - mod_symbol.importieren(roh["symbol_rechts"]) + mod_direction.import_(raw["direction"]), + mod_symbol.import_(raw["symbol_links"]), + mod_symbol.import_(raw["symbol_rechts"]) ) ); } @@ -224,16 +224,16 @@ module mod_vtm /** * @author kcf */ - lib_brauch.umsetzen + lib_trait.attend ( - brauch_aktor, - art, + trait_actuator, + kind, { - "beispiel": () => lib_aufruf.einpacken(art, beispiel()), - "drehen": (aktor, inkrement) => drehen(lib_aufruf.auspacken(aktor), inkrement), - "verwenden": (aktor, figur) => verwenden(lib_aufruf.auspacken(aktor), figur), - "exportieren": (aktor) => ({"art": art, "angaben": exportieren(aktor.angaben)}), - "importieren": (roh) => lib_aufruf.einpacken(art, importieren(roh["angaben"])), + "example": () => lib_call.wrap(kind, example()), + "rotate": (actuator, inkrement) => rotate(lib_call.unwrap(actuator), inkrement), + "use": (actuator, token) => use(lib_call.unwrap(actuator), token), + "export": (actuator) => ({"kind": kind, "data": export_(actuator.data)}), + "import": (raw) => lib_call.wrap(kind, import_(raw["data"])), } ) ; diff --git a/quelldatein/aufbau/aktoren/schreiber.ts b/quelldatein/aufbau/aktoren/schreiber.ts index fab61d4..661b746 100644 --- a/quelldatein/aufbau/aktoren/schreiber.ts +++ b/quelldatein/aufbau/aktoren/schreiber.ts @@ -19,10 +19,10 @@ module mod_vtm { - export module mod_aufbau + export module mod_model { - export module mod_aktor + export module mod_actuator { export module mod_schreiber @@ -31,16 +31,16 @@ module mod_vtm /** * @author kcf */ - let art : string = "schreiber"; + let kind : string = "schreiber"; /** * @author kcf */ - export type typ_schreiber = + export type type_schreiber = { - richtung : mod_richtung.typ_richtung; - symbol : mod_symbol.typ_symbol; + direction : mod_direction.type_direction; + symbol : mod_symbol.type_symbol; } ; @@ -48,15 +48,15 @@ module mod_vtm /** * @author kcf */ - function erstellen + function create ( - richtung : mod_richtung.typ_richtung, - symbol : mod_symbol.typ_symbol + direction : mod_direction.type_direction, + symbol : mod_symbol.type_symbol ) - : typ_schreiber + : type_schreiber { return { - "richtung": richtung, + "direction": direction, "symbol": symbol, }; } @@ -65,50 +65,50 @@ module mod_vtm /** * @author kcf */ - export function erstellen_aktor + export function create_actuator ( - richtung : mod_richtung.typ_richtung, - symbol : mod_symbol.typ_symbol + direction : mod_direction.type_direction, + symbol : mod_symbol.type_symbol ) - : mod_aktor.typ_aktor + : mod_actuator.type_actuator { - return lib_aufruf.einpacken(art, erstellen(richtung, symbol)); + return lib_call.wrap(kind, create(direction, symbol)); } /** * @author kcf */ - function beispiel + function example ( ) - : typ_schreiber + : type_schreiber { - return erstellen(0, 0); + return create(0, 0); } /** * @author kcf */ - export function richtung_lesen + export function direction_read ( - schreiber : typ_schreiber + schreiber : type_schreiber ) - : mod_richtung.typ_richtung + : mod_direction.type_direction { - return schreiber.richtung; + return schreiber.direction; } /** * @author kcf */ - export function symbol_lesen + export function symbol_read ( - schreiber : typ_schreiber + schreiber : type_schreiber ) - : mod_symbol.typ_symbol + : mod_symbol.type_symbol { return schreiber.symbol; } @@ -117,44 +117,44 @@ module mod_vtm /** * @author kcf */ - function drehen + function rotate ( - schreiber : typ_schreiber, + schreiber : type_schreiber, inkrement : int = +1 ) : void { - schreiber.richtung = mod_richtung.addieren(schreiber.richtung, inkrement); + schreiber.direction = mod_direction.add(schreiber.direction, inkrement); } /** * @author kcf */ - function verwenden + function use ( - schreiber : typ_schreiber, - figur : mod_figur.typ_figur + schreiber : type_schreiber, + token : mod_token.type_token ) : void { - mod_figur.schreiben(figur, schreiber.symbol); - mod_figur.bewegen(figur, schreiber.richtung); + mod_token.write(token, schreiber.symbol); + mod_token.move(token, schreiber.direction); } /** * @author kcf */ - function exportieren + function export_ ( - schreiber : typ_schreiber + schreiber : type_schreiber ) : any { return { - "richtung": mod_richtung.exportieren(schreiber.richtung), - "symbol": mod_symbol.exportieren(schreiber.symbol), + "direction": mod_direction.export_(schreiber.direction), + "symbol": mod_symbol.export_(schreiber.symbol), }; } @@ -162,17 +162,17 @@ module mod_vtm /** * @author kcf */ - function importieren + function import_ ( - roh : any + raw : any ) - : typ_schreiber + : type_schreiber { return ( - erstellen + create ( - mod_richtung.importieren(roh["richtung"]), - mod_symbol.importieren(roh["symbol"]) + mod_direction.import_(raw["direction"]), + mod_symbol.import_(raw["symbol"]) ) ); } @@ -181,16 +181,16 @@ module mod_vtm /** * @author kcf */ - lib_brauch.umsetzen + lib_trait.attend ( - brauch_aktor, - art, + trait_actuator, + kind, { - "beispiel": () => lib_aufruf.einpacken(art, beispiel()), - "drehen": (aktor, inkrement) => drehen(lib_aufruf.auspacken(aktor), inkrement), - "verwenden": (aktor, figur) => verwenden(lib_aufruf.auspacken(aktor), figur), - "exportieren": (aktor) => ({"art": art, "angaben": exportieren(aktor.angaben)}), - "importieren": (roh) => lib_aufruf.einpacken(art, importieren(roh["angaben"])), + "example": () => lib_call.wrap(kind, example()), + "rotate": (actuator, inkrement) => rotate(lib_call.unwrap(actuator), inkrement), + "use": (actuator, token) => use(lib_call.unwrap(actuator), token), + "export": (actuator) => ({"kind": kind, "data": export_(actuator.data)}), + "import": (raw) => lib_call.wrap(kind, import_(raw["data"])), } ) ; diff --git a/quelldatein/aufbau/aktoren/verwerfer.ts b/quelldatein/aufbau/aktoren/verwerfer.ts index 7ce9017..1abdf0e 100644 --- a/quelldatein/aufbau/aktoren/verwerfer.ts +++ b/quelldatein/aufbau/aktoren/verwerfer.ts @@ -19,10 +19,10 @@ module mod_vtm { - export module mod_aufbau + export module mod_model { - export module mod_aktor + export module mod_actuator { export module mod_verwerfer @@ -31,13 +31,13 @@ module mod_vtm /** * @author kcf */ - let art : string = "verwerfer"; + let kind : string = "verwerfer"; /** * @author kcf */ - export type typ_verwerfer = + export type type_verwerfer = { } ; @@ -46,10 +46,10 @@ module mod_vtm /** * @author kcf */ - function erstellen + function create ( ) - : typ_verwerfer + : type_verwerfer { return { }; @@ -59,33 +59,33 @@ module mod_vtm /** * @author kcf */ - export function erstellen_aktor + export function create_actuator ( ) - : mod_aktor.typ_aktor + : mod_actuator.type_actuator { - return lib_aufruf.einpacken(art, erstellen()); + return lib_call.wrap(kind, create()); } /** * @author kcf */ - function beispiel + function example ( ) - : typ_verwerfer + : type_verwerfer { - return erstellen(); + return create(); } /** * @author kcf */ - function drehen + function rotate ( - verwerfer : typ_verwerfer, + verwerfer : type_verwerfer, inkrement ?: int ) : void @@ -96,23 +96,23 @@ module mod_vtm /** * @author kcf */ - function verwenden + function use ( - verwerfer : typ_verwerfer, - figur : mod_figur.typ_figur + verwerfer : type_verwerfer, + token : mod_token.type_token ) : void { - mod_figur.verwerfen(figur); + mod_token.reject(token); } /** * @author kcf */ - function exportieren + function export_ ( - verwerfer : typ_verwerfer + verwerfer : type_verwerfer ) : any { @@ -124,14 +124,14 @@ module mod_vtm /** * @author kcf */ - function importieren + function import_ ( - roh : any + raw : any ) - : typ_verwerfer + : type_verwerfer { return ( - erstellen + create ( ) ); @@ -141,16 +141,16 @@ module mod_vtm /** * @author kcf */ - lib_brauch.umsetzen + lib_trait.attend ( - brauch_aktor, - art, + trait_actuator, + kind, { - "beispiel": () => lib_aufruf.einpacken(art, beispiel()), - "drehen": (aktor, inkrement) => drehen(lib_aufruf.auspacken(aktor), inkrement), - "verwenden": (aktor, figur) => verwenden(lib_aufruf.auspacken(aktor), figur), - "exportieren": (aktor) => ({"art": art, "angaben": exportieren(aktor.angaben)}), - "importieren": (roh) => lib_aufruf.einpacken(art, importieren(roh["angaben"])), + "example": () => lib_call.wrap(kind, example()), + "rotate": (actuator, inkrement) => rotate(lib_call.unwrap(actuator), inkrement), + "use": (actuator, token) => use(lib_call.unwrap(actuator), token), + "export": (actuator) => ({"kind": kind, "data": export_(actuator.data)}), + "import": (raw) => lib_call.wrap(kind, import_(raw["data"])), } ) ; diff --git a/quelldatein/aufbau/aufgaben/akzeptoraufgabe.ts b/quelldatein/aufbau/aufgaben/akzeptoraufgabe.ts index f631bb8..4703beb 100644 --- a/quelldatein/aufbau/aufgaben/akzeptoraufgabe.ts +++ b/quelldatein/aufbau/aufgaben/akzeptoraufgabe.ts @@ -19,21 +19,21 @@ module mod_vtm { - export module mod_aufbau + export module mod_model { - export module mod_akzeptoraufgabe + export module mod_acceptortask { /** * @author kcf */ - export type typ_akzeptoraufgabe = + export type type_acceptortask = { id : string; titel : string; text : string; - tests : Array; + tests : Array; } ; @@ -41,14 +41,14 @@ module mod_vtm /** * @author kcf */ - export function erstellen + export function create ( id : string, titel : string, text : string, - tests : Array + tests : Array ) - : typ_akzeptoraufgabe + : type_acceptortask { return { "id": id, @@ -64,11 +64,11 @@ module mod_vtm */ export function id ( - akzeptoraufgabe : typ_akzeptoraufgabe + acceptortask : type_acceptortask ) : string { - return akzeptoraufgabe.id; + return acceptortask.id; } @@ -77,11 +77,11 @@ module mod_vtm */ export function titel ( - akzeptoraufgabe : typ_akzeptoraufgabe + acceptortask : type_acceptortask ) : string { - return akzeptoraufgabe.titel; + return acceptortask.titel; } @@ -90,11 +90,11 @@ module mod_vtm */ export function text ( - akzeptoraufgabe : typ_akzeptoraufgabe + acceptortask : type_acceptortask ) : string { - return akzeptoraufgabe.text; + return acceptortask.text; } @@ -103,11 +103,11 @@ module mod_vtm */ export function tests ( - akzeptoraufgabe : typ_akzeptoraufgabe + acceptortask : type_acceptortask ) - : Array + : Array { - return akzeptoraufgabe.tests; + return acceptortask.tests; } } diff --git a/quelldatein/aufbau/aufgaben/akzeptortest.ts b/quelldatein/aufbau/aufgaben/akzeptortest.ts index 1a3f396..dea9cfa 100644 --- a/quelldatein/aufbau/aufgaben/akzeptortest.ts +++ b/quelldatein/aufbau/aufgaben/akzeptortest.ts @@ -19,19 +19,19 @@ module mod_vtm { - export module mod_aufbau + export module mod_model { - export module mod_akzeptortest + export module mod_acceptortest { /** * @author kcf */ - export type typ_akzeptortest = + export type type_acceptortest = { - eingabe : Array; - annehmen : boolean; + input : Array; + accept : boolean; } ; @@ -39,16 +39,16 @@ module mod_vtm /** * @author kcf */ - export function erstellen + export function create ( - eingabe : Array, - annehmen : boolean + input : Array, + accept : boolean ) - : typ_akzeptortest + : type_acceptortest { return { - "eingabe": eingabe, - "annehmen": annehmen, + "input": input, + "accept": accept, }; } @@ -56,13 +56,13 @@ module mod_vtm /** * @author kcf */ - export function eingabe + export function input ( - akzeptortest : typ_akzeptortest + acceptortest : type_acceptortest ) - : Array + : Array { - return akzeptortest.eingabe; + return acceptortest.input; } @@ -71,13 +71,13 @@ module mod_vtm */ export function pruefen ( - akzeptortest : typ_akzeptortest, - angenommen : boolean, - ausgabe : Array + acceptortest : type_acceptortest, + accepted : boolean, + ausgabe : Array ) : boolean { - return (akzeptortest.annehmen === angenommen); + return (acceptortest.accept === accepted); } } diff --git a/quelldatein/aufbau/aufgaben/aufgabe.ts b/quelldatein/aufbau/aufgaben/aufgabe.ts index 1162ad6..a1cd1d0 100644 --- a/quelldatein/aufbau/aufgaben/aufgabe.ts +++ b/quelldatein/aufbau/aufgaben/aufgabe.ts @@ -19,22 +19,22 @@ module mod_vtm { - export module mod_aufbau + export module mod_model { - export module mod_aufgabe + export module mod_task { /** * @author kcf */ - export type typ_aufgabe = lib_aufruf.typ_komplex; + export type type_task = lib_call.type_complex; /** * @author kcf */ - var _liste : Array = []; + var _liste : Array = []; /** @@ -42,17 +42,17 @@ module mod_vtm */ export function id ( - aufgabe : typ_aufgabe + task : type_task ) : string { return ( - lib_aufruf.fallunterscheidung + lib_call.distinguish ( - aufgabe, + task, { - "akzeptoraufgabe": (angaben) => mod_akzeptoraufgabe.id(angaben), - "transduktoraufgabe": (angaben) => mod_transduktoraufgabe.id(angaben), + "acceptortask": (data) => mod_acceptortask.id(data), + "transductortask": (data) => mod_transductortask.id(data), } ) ); @@ -64,17 +64,17 @@ module mod_vtm */ export function titel ( - aufgabe : typ_aufgabe + task : type_task ) : string { return ( - lib_aufruf.fallunterscheidung + lib_call.distinguish ( - aufgabe, + task, { - "akzeptoraufgabe": (angaben) => mod_akzeptoraufgabe.titel(angaben), - "transduktoraufgabe": (angaben) => mod_transduktoraufgabe.titel(angaben), + "acceptortask": (data) => mod_acceptortask.titel(data), + "transductortask": (data) => mod_transductortask.titel(data), } ) ); @@ -86,17 +86,17 @@ module mod_vtm */ export function text ( - aufgabe : typ_aufgabe + task : type_task ) : string { return ( - lib_aufruf.fallunterscheidung + lib_call.distinguish ( - aufgabe, + task, { - "akzeptoraufgabe": (angaben) => mod_akzeptoraufgabe.text(angaben), - "transduktoraufgabe": (angaben) => mod_transduktoraufgabe.text(angaben), + "acceptortask": (data) => mod_acceptortask.text(data), + "transductortask": (data) => mod_transductortask.text(data), } ) ); @@ -108,22 +108,22 @@ module mod_vtm */ export function tests ( - aufgabe : typ_aufgabe + task : type_task ) - : Array + : Array { return ( - lib_aufruf.fallunterscheidung> + lib_call.distinguish> ( - aufgabe, + task, { - "akzeptoraufgabe": (angaben) => ( - mod_akzeptoraufgabe.tests(angaben) - .map(angaben_ => ({"art": "akzeptortest", "angaben": angaben_})) + "acceptortask": (data) => ( + mod_acceptortask.tests(data) + .map(data_ => ({"kind": "acceptortest", "data": data_})) ), - "transduktoraufgabe": (angaben) => ( - mod_transduktoraufgabe.tests(angaben) - .map(angaben_ => ({"art": "transduktortest", "angaben": angaben_})) + "transductortask": (data) => ( + mod_transductortask.tests(data) + .map(data_ => ({"kind": "transductortest", "data": data_})) ), } ) @@ -134,27 +134,27 @@ module mod_vtm /** * @author kcf */ - export function importieren(aufgabe_roh : any) : typ_aufgabe + export function import_(task_raw : any) : type_task { - switch (aufgabe_roh["art"]) + switch (task_raw["kind"]) { - case "akzeptor": + case "acceptor": { return { - "art": "akzeptoraufgabe", - "angaben": ( - mod_akzeptoraufgabe.erstellen + "kind": "acceptortask", + "data": ( + mod_acceptortask.create ( - aufgabe_roh["id"], - aufgabe_roh["parameter"]["titel"], - aufgabe_roh["parameter"]["text"], - aufgabe_roh["parameter"]["tests"].map + task_raw["id"], + task_raw["parameter"]["titel"], + task_raw["parameter"]["text"], + task_raw["parameter"]["tests"].map ( - test_roh => ( - mod_akzeptortest.erstellen + test_raw => ( + mod_acceptortest.create ( - test_roh["eingabe"], - test_roh["annehmen"] + test_raw["input"], + test_raw["accept"] ) ) ) @@ -163,23 +163,23 @@ module mod_vtm }; break; } - case "transduktor": + case "transductor": { return { - "art": "transduktoraufgabe", - "angaben": ( - mod_transduktoraufgabe.erstellen + "kind": "transductortask", + "data": ( + mod_transductortask.create ( - aufgabe_roh["id"], - aufgabe_roh["parameter"]["titel"], - aufgabe_roh["parameter"]["text"], - aufgabe_roh["parameter"]["tests"].map + task_raw["id"], + task_raw["parameter"]["titel"], + task_raw["parameter"]["text"], + task_raw["parameter"]["tests"].map ( - test_roh => ( - mod_transduktortest.erstellen + test_raw => ( + mod_transductortest.create ( - test_roh["eingabe"], - test_roh["ausgabe"] + test_raw["input"], + test_raw["output"] ) ) ) @@ -190,8 +190,8 @@ module mod_vtm } default: { - let meldung : string = "unbehandelte Art"; - throw (new Error(meldung)); + let message : string = "unbehandelte Art '" + task_raw["kind"] + "'"; + throw (new Error(message)); break; } } @@ -201,16 +201,16 @@ module mod_vtm /** * @author kcf */ - export function registrieren(aufgabe : typ_aufgabe) : void + export function registrieren(task : type_task) : void { - _liste.push(aufgabe); + _liste.push(task); } /** * @author kcf */ - export function holen(index : int) : typ_aufgabe + export function get(index : int) : type_task { return _liste[index]; } diff --git a/quelldatein/aufbau/aufgaben/test.ts b/quelldatein/aufbau/aufgaben/test.ts index 3c6e038..d46af5c 100644 --- a/quelldatein/aufbau/aufgaben/test.ts +++ b/quelldatein/aufbau/aufgaben/test.ts @@ -19,7 +19,7 @@ module mod_vtm { - export module mod_aufbau + export module mod_model { export module mod_test @@ -28,25 +28,25 @@ module mod_vtm /** * @author kcf */ - export type typ_test = lib_aufruf.typ_komplex; + export type type_test = lib_call.type_complex; /** * @author kcf */ - export function eingabe + export function input ( - test : typ_test + test : type_test ) - : Array + : Array { return ( - lib_aufruf.fallunterscheidung> + lib_call.distinguish> ( test, { - "akzeptortest": (angaben) => mod_akzeptortest.eingabe(angaben), - "transduktortest": (angaben) => mod_transduktortest.eingabe(angaben), + "acceptortest": (data) => mod_acceptortest.input(data), + "transductortest": (data) => mod_transductortest.input(data), } ) ); @@ -58,19 +58,19 @@ module mod_vtm */ export function pruefen ( - test : typ_test, - angenommen : boolean, - ausgabe : Array + test : type_test, + accepted : boolean, + ausgabe : Array ) : boolean { return ( - lib_aufruf.fallunterscheidung + lib_call.distinguish ( test, { - "akzeptortest": (angaben) => mod_akzeptortest.pruefen(angaben, angenommen, ausgabe), - "transduktortest": (angaben) => mod_transduktortest.pruefen(angaben, angenommen, ausgabe), + "acceptortest": (data) => mod_acceptortest.pruefen(data, accepted, ausgabe), + "transductortest": (data) => mod_transductortest.pruefen(data, accepted, ausgabe), } ) ); @@ -80,37 +80,37 @@ module mod_vtm /** * @author kcf */ - export function importieren + export function import_ ( - test_roh : any + test_raw : any ) - : typ_test + : type_test { - switch (test_roh["art"]) + switch (test_raw["kind"]) { - case "akzeptortest": + case "acceptortest": { return { - "art": "akzeptortest", - "angaben": ( - mod_akzeptortest.erstellen + "kind": "acceptortest", + "data": ( + mod_acceptortest.create ( - test_roh["angaben"]["eingabe"], - test_roh["angaben"]["annehmen"] + test_raw["data"]["input"], + test_raw["data"]["accept"] ) ), }; break; } - case "transduktortest": + case "transductortest": { return { - "art": "transduktortest", - "angaben": ( - mod_transduktortest.erstellen + "kind": "transductortest", + "data": ( + mod_transductortest.create ( - test_roh["angaben"]["eingabe"], - test_roh["angaben"]["ausgabe"] + test_raw["data"]["input"], + test_raw["data"]["output"] ) ), }; diff --git a/quelldatein/aufbau/aufgaben/transduktoraufgabe.ts b/quelldatein/aufbau/aufgaben/transduktoraufgabe.ts index 81d8cb4..2a4d5b0 100644 --- a/quelldatein/aufbau/aufgaben/transduktoraufgabe.ts +++ b/quelldatein/aufbau/aufgaben/transduktoraufgabe.ts @@ -19,21 +19,21 @@ module mod_vtm { - export module mod_aufbau + export module mod_model { - export module mod_transduktoraufgabe + export module mod_transductortask { /** * @author kcf */ - export type typ_transduktoraufgabe = + export type type_transductortask = { id : string; titel : string; text : string; - tests : Array; + tests : Array; } ; @@ -41,14 +41,14 @@ module mod_vtm /** * @author kcf */ - export function erstellen + export function create ( id : string, titel : string, text : string, - tests : Array + tests : Array ) - : typ_transduktoraufgabe + : type_transductortask { return { "id": id, @@ -64,11 +64,11 @@ module mod_vtm */ export function id ( - transduktoraufgabe : typ_transduktoraufgabe + transductortask : type_transductortask ) : string { - return transduktoraufgabe.id; + return transductortask.id; } @@ -77,11 +77,11 @@ module mod_vtm */ export function titel ( - transduktoraufgabe : typ_transduktoraufgabe + transductortask : type_transductortask ) : string { - return transduktoraufgabe.titel; + return transductortask.titel; } @@ -90,11 +90,11 @@ module mod_vtm */ export function text ( - transduktoraufgabe : typ_transduktoraufgabe + transductortask : type_transductortask ) : string { - return transduktoraufgabe.text; + return transductortask.text; } @@ -103,11 +103,11 @@ module mod_vtm */ export function tests ( - transduktoraufgabe : typ_transduktoraufgabe + transductortask : type_transductortask ) - : Array + : Array { - return transduktoraufgabe.tests; + return transductortask.tests; } } diff --git a/quelldatein/aufbau/aufgaben/transduktortest.ts b/quelldatein/aufbau/aufgaben/transduktortest.ts index aebb6c8..5c5ae3e 100644 --- a/quelldatein/aufbau/aufgaben/transduktortest.ts +++ b/quelldatein/aufbau/aufgaben/transduktortest.ts @@ -19,19 +19,19 @@ module mod_vtm { - export module mod_aufbau + export module mod_model { - export module mod_transduktortest + export module mod_transductortest { /** * @author kcf */ - export type typ_transduktortest = + export type type_transductortest = { - eingabe : Array; - ausgabe : Array; + input : Array; + output : Array; } ; @@ -39,16 +39,16 @@ module mod_vtm /** * @author kcf */ - export function erstellen + export function create ( - eingabe : Array, - ausgabe : Array + input : Array, + output : Array ) - : typ_transduktortest + : type_transductortest { return { - "eingabe": eingabe, - "ausgabe": ausgabe, + "input": input, + "output": output, }; } @@ -56,13 +56,13 @@ module mod_vtm /** * @author kcf */ - export function eingabe + export function input ( - transduktortest : typ_transduktortest + transductortest : type_transductortest ) - : Array + : Array { - return transduktortest.eingabe; + return transductortest.input; } @@ -71,29 +71,29 @@ module mod_vtm */ export function pruefen ( - transduktortest : typ_transduktortest, - angenommen : boolean, - ausgabe : Array + transductortest : type_transductortest, + accepted : boolean, + output : Array ) : boolean { - if (transduktortest.ausgabe.length !== ausgabe.length) + if (transductortest.output.length !== output.length) { return false; } else { let gleich : boolean = true; - for (let index : int = 0; index < transduktortest.ausgabe.length; index += 1) + for (let index : int = 0; index < transductortest.output.length; index += 1) { - if (! mod_vtm.mod_aufbau.mod_symbol.vergleichen(transduktortest.ausgabe[index], ausgabe[index])) + if (! mod_vtm.mod_model.mod_symbol.vergleichen(transductortest.output[index], output[index])) { gleich = false; break; } else { - // nichts tun + // nothing tun } } return gleich; diff --git a/quelldatein/aufbau/figur.ts b/quelldatein/aufbau/figur.ts index 3f7a217..efd35c7 100644 --- a/quelldatein/aufbau/figur.ts +++ b/quelldatein/aufbau/figur.ts @@ -19,20 +19,20 @@ module mod_vtm { - export module mod_aufbau + export module mod_model { - export module mod_figur + export module mod_token { /** * @author kcf */ - export type typ_figur = + export type type_token = { - zustand : mod_zustand.typ_zustand; - band : Array; - stelle : mod_stelle.typ_stelle; + state : mod_state.type_state; + tape : Array; + spot : mod_spot.type_spot; } ; @@ -40,17 +40,17 @@ module mod_vtm /** * @author kcf */ - export function erstellen + export function create ( - band : Array = [], - stelle : mod_stelle.typ_stelle = mod_stelle.null_() + tape : Array = [], + spot : mod_spot.type_spot = mod_spot.null_() ) - : typ_figur + : type_token { return { - "zustand": mod_zustand.laufend, - "band": band, - "stelle": stelle, + "state": mod_state.running, + "tape": tape, + "spot": spot, }; } @@ -58,87 +58,87 @@ module mod_vtm /** * @author kcf */ - export function zustand_lesen + export function state_read ( - figur : typ_figur + token : type_token ) - : mod_zustand.typ_zustand + : mod_state.type_state { - return figur.zustand; + return token.state; } /** * @author kcf */ - export function band_lesen + export function tape_read ( - figur : typ_figur + token : type_token ) - : Array + : Array { - return figur.band; + return token.tape; } /** * @author kcf */ - export function stelle_lesen + export function spot_read ( - figur : typ_figur + token : type_token ) - : mod_stelle.typ_stelle + : mod_spot.type_spot { - return figur.stelle; + return token.spot; } /** * @author kcf */ - export function bewegen + export function move ( - figur : typ_figur, - richtung : mod_richtung.typ_richtung + token : type_token, + direction : mod_direction.type_direction ) : void { - let summand : mod_stelle.typ_stelle = mod_stelle.von_richtung(richtung); - figur.stelle = mod_stelle.addieren(figur.stelle, summand); + let summand : mod_spot.type_spot = mod_spot.von_direction(direction); + token.spot = mod_spot.add(token.spot, summand); } /** * @author kcf */ - export function schreiben + export function write ( - figur : typ_figur, - symbol : mod_symbol.typ_symbol + token : type_token, + symbol : mod_symbol.type_symbol ) : void { - figur.band.push(symbol); + token.tape.push(symbol); } /** * @author kcf */ - export function lesen + export function read ( - figur : typ_figur + token : type_token ) - : lib_fehlermonade.typ_fehlermonade + : lib_errormonade.type_errormonade { - if (figur.band.length <= 0) + if (token.tape.length <= 0) { - return (lib_fehlermonade.erstellen_nichts()); + return (lib_errormonade.create_nothing()); } else { - return (lib_fehlermonade.erstellen_schlicht(figur.band[0])); + return (lib_errormonade.create_just(token.tape[0])); } } @@ -146,20 +146,20 @@ module mod_vtm /** * @author kcf */ - export function schieben + export function shift ( - figur : typ_figur + token : type_token ) : void { - if (figur.band.length <= 0) + if (token.tape.length <= 0) { - let meldung : string = "Band ist leer"; - throw (new Error(meldung)); + let message : string = "Band ist leer"; + throw (new Error(message)); } else { - figur.band.shift(); + token.tape.shift(); } } @@ -167,26 +167,26 @@ module mod_vtm /** * @author kcf */ - export function annehmen + export function accept ( - figur : typ_figur + token : type_token ) : void { - figur.zustand = mod_zustand.angenommen; + token.state = mod_state.accepted; } /** * @author kcf */ - export function verwerfen + export function reject ( - figur : typ_figur + token : type_token ) : void { - figur.zustand = mod_zustand.abgelehnt; + token.state = mod_state.rejected; } } diff --git a/quelldatein/aufbau/modus.ts b/quelldatein/aufbau/modus.ts index 8e38372..c669363 100644 --- a/quelldatein/aufbau/modus.ts +++ b/quelldatein/aufbau/modus.ts @@ -19,25 +19,25 @@ module mod_vtm { - export module mod_aufbau + export module mod_model { - export module mod_modus + export module mod_mode { /** * @author kcf */ - export type typ_modus = int; + export type type_mode = int; /** * @author kcf */ export const initial = 0; - export const ungewiss = 1; - export const fehlerhaft = 2; - export const korrekt = 3; + export const uncertain = 1; + export const wrong = 2; + export const correct = 3; } diff --git a/quelldatein/aufbau/partie.ts b/quelldatein/aufbau/partie.ts index 4e281ee..48723ec 100644 --- a/quelldatein/aufbau/partie.ts +++ b/quelldatein/aufbau/partie.ts @@ -19,23 +19,23 @@ module mod_vtm { - export module mod_aufbau + export module mod_model { - export module mod_partie + export module mod_round { /** * @author kcf */ - export type typ_partie = + export type type_round = { - welt : mod_welt.typ_welt; - figur : lib_fehlermonade.typ_fehlermonade; - aufgabe : mod_aufgabe.typ_aufgabe; - testindex : lib_fehlermonade.typ_fehlermonade; - modus : mod_modus.typ_modus; - lauscher : {[ereignis : string] : Array<(angaben ?: any)=>void>}; + world : mod_world.type_world; + token : lib_errormonade.type_errormonade; + task : mod_task.type_task; + testindex : lib_errormonade.type_errormonade; + mode : mod_mode.type_mode; + listeners : {[event : string] : Array<(data ?: any)=>void>}; } ; @@ -43,29 +43,33 @@ module mod_vtm /** * @author kcf */ - export function erstellen + export function create ( - aufgabe : mod_aufgabe.typ_aufgabe + task : mod_task.type_task ) - : typ_partie + : type_round { - 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; + let round : type_round = + { + "world": undefined, + "token": undefined, + "task": task, + "testindex": undefined, + "mode": undefined, + "listeners": undefined, + } + ; + round.listeners = + { + "aendrung_task": [], + "aendrung_world": [], + "aendrung_token": [], + "aendrung_mode": [], + } + ; + world_clear(round, false); + reset(round, false); + return round; } @@ -74,20 +78,20 @@ module mod_vtm */ export function lauschen ( - partie : typ_partie, - ereignis : string, - prozedur : (angaben ?: any)=>void + round : type_round, + event : string, + procedure : (data ?: any)=>void ) : void { - if (ereignis in partie.lauscher) + if (event in round.listeners) { - partie.lauscher[ereignis].push(prozedur); + round.listeners[event].push(procedure); } else { - let meldung : string = "kein Ereignis mit diesem Name"; - throw (new Error(meldung)); + let message : string = "kein Ereignis mit diesem Name"; + throw (new Error(message)); } } @@ -95,28 +99,28 @@ module mod_vtm /** * @author kcf */ - function benachrichtigen + function notify ( - partie : typ_partie, - ereignis : string, - angaben : any = {} + round : type_round, + event : string, + data : any = {} ) : void { - if (ereignis in partie.lauscher) + if (event in round.listeners) { - partie.lauscher[ereignis].forEach + round.listeners[event].forEach ( - prozedur => + procedure => { - prozedur(angaben); + procedure(data); } ) ; } else { - let meldung : string = "kein Ereignis mit diesem Name"; - throw (new Error(meldung)); + let message : string = "kein Ereignis mit diesem Name"; + throw (new Error(message)); } } @@ -124,24 +128,24 @@ module mod_vtm /** * @author kcf */ - export function zuruecksetzen + export function reset ( - partie : typ_partie, - bescheid_geben : boolean = true + round : type_round, + inform : boolean = true ) : void { - partie.figur = (lib_fehlermonade.erstellen_nichts()); - partie.testindex = (lib_fehlermonade.erstellen_nichts()); - partie.modus = mod_modus.initial; - if (bescheid_geben) + round.token = (lib_errormonade.create_nothing()); + round.testindex = (lib_errormonade.create_nothing()); + round.mode = mod_mode.initial; + if (inform) { - benachrichtigen(partie, "aenderung_figur", {}); - benachrichtigen(partie, "aenderung_modus", {}); + notify(round, "aendrung_token", {}); + notify(round, "aendrung_mode", {}); } else { - // nichts tun + // nothing tun } } @@ -149,64 +153,64 @@ module mod_vtm /** * @author kcf */ - export function aufgabe_lesen + export function task_read ( - partie : typ_partie + round : type_round ) - : mod_aufgabe.typ_aufgabe + : mod_task.type_task { - return partie.aufgabe; + return round.task; } /** * @author kcf */ - export function aufgabe_setzen + export function task_set ( - partie : typ_partie, - aufgabe : mod_aufgabe.typ_aufgabe + round : type_round, + task : mod_task.type_task ) : void { - partie.aufgabe = aufgabe; - // partie.welt_leeren(); - benachrichtigen(partie, "aenderung_aufgabe", {}); - zuruecksetzen(partie); + round.task = task; + // round.world_clear(); + notify(round, "aendrung_task", {}); + reset(round); } /** * @author kcf */ - export function welt_lesen + export function world_read ( - partie : typ_partie + round : type_round ) - : mod_welt.typ_welt + : mod_world.type_world { - return partie.welt; + return round.world; } /** * @author kcf */ - export function welt_setzen + export function world_set ( - partie : typ_partie, - welt : mod_welt.typ_welt, - bescheid_geben : boolean = true + round : type_round, + world : mod_world.type_world, + inform : boolean = true ) : void { - partie.welt = welt; - if (bescheid_geben) + round.world = world; + if (inform) { - benachrichtigen(partie, "aenderung_welt", {}); + notify(round, "aendrung_world", {}); } else { - // nichts tun + // nothing tun } } @@ -214,21 +218,21 @@ module mod_vtm /** * @author kcf */ - export function welt_leeren + export function world_clear ( - partie : typ_partie, - bescheid_geben : boolean = true + round : type_round, + inform : boolean = true ) : void { - partie.welt = mod_welt.blanko(); - if (bescheid_geben) + round.world = mod_world.blanko(); + if (inform) { - benachrichtigen(partie, "aenderung_welt", {}); + notify(round, "aendrung_world", {}); } else { - // nichts tun + // nothing tun } } @@ -236,58 +240,58 @@ module mod_vtm /** * @author kcf */ - export function figur_lesen + export function token_read ( - partie : typ_partie + round : type_round ) - : lib_fehlermonade.typ_fehlermonade + : lib_errormonade.type_errormonade { - return partie.figur; + return round.token; } /** * @author kcf */ - export function modus_lesen + export function mode_read ( - partie : typ_partie + round : type_round ) - : mod_modus.typ_modus + : mod_mode.type_mode { - return partie.modus; + return round.mode; } /** * @author kcf */ - export function welt_feld_wechseln + export function world_tile_wechseln ( - partie : typ_partie, - stelle : mod_stelle.typ_stelle, + round : type_round, + spot : mod_spot.type_spot, umgekehrt : boolean = false ) : void { - if (! (partie.modus === mod_modus.initial)) + if (! (round.mode === mod_mode.initial)) { - let meldung : string = "gesperrt"; + let message : string = "gesperrt"; } else { - mod_welt.feld_wechseln(partie.welt, stelle, umgekehrt); - benachrichtigen + mod_world.tile_wechseln(round.world, spot, umgekehrt); + notify ( - partie, - "aenderung_welt", + round, + "aendrung_world", { - "art": "feld_wechseln", - "angaben": + "kind": "tile_wechseln", + "data": { - "stelle": stelle, + "spot": spot, "umgekehrt": umgekehrt, - "feld": mod_welt.feld_holen(partie.welt, stelle), + "tile": mod_world.tile_get(round.world, spot), } } ) @@ -299,22 +303,22 @@ module mod_vtm /** * @author kcf */ - export function welt_feld_drehen + export function world_tile_rotate ( - partie : typ_partie, - stelle : mod_stelle.typ_stelle, + round : type_round, + spot : mod_spot.type_spot, inkrement : int = +1 ) : void { - if (! (partie.modus === mod_modus.initial)) + if (! (round.mode === mod_mode.initial)) { - let meldung : string = "gesperrt"; + let message : string = "gesperrt"; } else { - mod_welt.feld_drehen(partie.welt, stelle, inkrement); - benachrichtigen(partie, "aenderung_welt", {}); + mod_world.tile_rotate(round.world, spot, inkrement); + notify(round, "aendrung_world", {}); } } @@ -322,67 +326,67 @@ module mod_vtm /** * @author kcf */ - export function fortfahren + export function resume ( - partie : typ_partie + round : type_round ) : void { - switch (partie.modus) + switch (round.mode) { - case mod_modus.initial: + case mod_mode.initial: { - partie.modus = mod_modus.ungewiss; - partie.testindex = (lib_fehlermonade.erstellen_schlicht(0)); - benachrichtigen(partie, "aenderung_modus", {}); + round.mode = mod_mode.uncertain; + round.testindex = (lib_errormonade.create_just(0)); + notify(round, "aendrung_mode", {}); break; } - case mod_modus.ungewiss: + case mod_mode.uncertain: { - if (! lib_fehlermonade.voll(partie.figur)) + if (! lib_errormonade.filled(round.token)) { - let test : mod_test.typ_test = mod_aufgabe.tests(partie.aufgabe)[lib_fehlermonade.lesen(partie.testindex)]; - let band : Array = mod_vtm.mod_helfer.liste_kopieren(mod_test.eingabe(test)); - let stelle : mod_stelle.typ_stelle = mod_welt.erzeuger_finden(partie.welt); - partie.figur = ( - lib_fehlermonade.erstellen_schlicht + let test : mod_test.type_test = mod_task.tests(round.task)[lib_errormonade.read(round.testindex)]; + let tape : Array = mod_vtm.mod_helfer.list_copy(mod_test.input(test)); + let spot : mod_spot.type_spot = mod_world.erzeuger_finden(round.world); + round.token = ( + lib_errormonade.create_just ( - mod_figur.erstellen + mod_token.create ( - band, - stelle + tape, + spot ) ) ); } else { - let figur : mod_figur.typ_figur = lib_fehlermonade.lesen(partie.figur); - let stelle : mod_stelle.typ_stelle = mod_figur.stelle_lesen(figur); - let aktor_ : lib_fehlermonade.typ_fehlermonade = mod_welt.feld_holen(partie.welt, stelle); - let aktor : mod_aktor.typ_aktor = ( - lib_fehlermonade.voll(aktor_) - ? lib_fehlermonade.lesen(aktor_) - : mod_aktor.mod_verwerfer.erstellen_aktor() + let token : mod_token.type_token = lib_errormonade.read(round.token); + let spot : mod_spot.type_spot = mod_token.spot_read(token); + let actuator_ : lib_errormonade.type_errormonade = mod_world.tile_get(round.world, spot); + let actuator : mod_actuator.type_actuator = ( + lib_errormonade.filled(actuator_) + ? lib_errormonade.read(actuator_) + : mod_actuator.mod_verwerfer.create_actuator() ); - mod_aktor.verwenden(aktor, figur); - let zustand : mod_zustand.typ_zustand = mod_figur.zustand_lesen(figur); - if (zustand === mod_zustand.laufend) + mod_actuator.use(actuator, token); + let state : mod_state.type_state = mod_token.state_read(token); + if (state === mod_state.running) { - // nichts tun + // nothing tun } - else if ((zustand === mod_zustand.angenommen) || (zustand === mod_zustand.abgelehnt)) + else if ((state === mod_state.accepted) || (state === mod_state.rejected)) { - let angenommen : boolean = (zustand === mod_zustand.angenommen); - let ausgabe : Array = mod_figur.band_lesen(figur); - partie.figur = (lib_fehlermonade.erstellen_nichts()); - let testindex : int = lib_fehlermonade.lesen(partie.testindex); - let tests : Array = mod_aufgabe.tests(partie.aufgabe); - let test : mod_test.typ_test = tests[testindex]; - if (! mod_test.pruefen(test, angenommen, ausgabe)) + let accepted : boolean = (state === mod_state.accepted); + let ausgabe : Array = mod_token.tape_read(token); + round.token = (lib_errormonade.create_nothing()); + let testindex : int = lib_errormonade.read(round.testindex); + let tests : Array = mod_task.tests(round.task); + let test : mod_test.type_test = tests[testindex]; + if (! mod_test.pruefen(test, accepted, ausgabe)) { - partie.modus = mod_modus.fehlerhaft; - benachrichtigen(partie, "aenderung_modus", {}); + round.mode = mod_mode.wrong; + notify(round, "aendrung_mode", {}); } else { @@ -390,40 +394,40 @@ module mod_vtm if (testindex < tests.length) { // nächsten Test auswählen - partie.testindex = (lib_fehlermonade.erstellen_schlicht(testindex)); + round.testindex = (lib_errormonade.create_just(testindex)); } else { - // auf Modus "korrekt" wechseln - partie.testindex = (lib_fehlermonade.erstellen_nichts()); - partie.modus = mod_modus.korrekt; - benachrichtigen(partie, "aenderung_modus", {}); + // auf Modus "correct" wechseln + round.testindex = (lib_errormonade.create_nothing()); + round.mode = mod_mode.correct; + notify(round, "aendrung_mode", {}); } } } else { - let meldung : string = "unbehandelter Zustand"; - throw (new Error(meldung)); + let message : string = "unbehandelter Zustand"; + throw (new Error(message)); } } - benachrichtigen(partie, "aenderung_figur", {}); + notify(round, "aendrung_token", {}); break; } - case mod_modus.fehlerhaft: + case mod_mode.wrong: { - // nichts tun + // nothing tun break; } - case mod_modus.korrekt: + case mod_mode.correct: { - // nichts tun + // nothing tun break; } default: { - let meldung : string = "unbehandelter Modus"; - throw (new Error(meldung)); + let message : string = "unbehandelter Modus"; + throw (new Error(message)); break; } } diff --git a/quelldatein/aufbau/richtung.ts b/quelldatein/aufbau/richtung.ts index a296b9b..6e482ec 100644 --- a/quelldatein/aufbau/richtung.ts +++ b/quelldatein/aufbau/richtung.ts @@ -19,42 +19,42 @@ module mod_vtm { - export module mod_aufbau + export module mod_model { - export module mod_richtung + export module mod_direction { /** * @author kcf */ - export type typ_richtung = int; + export type type_direction = int; /** * @author kcf */ - export function addieren(richtung1 : typ_richtung, richtung2 : typ_richtung) : typ_richtung + export function add(direction1 : type_direction, direction2 : type_direction) : type_direction { - return lib_mathematik.mod(richtung1 + richtung2, 6); + return lib_math.mod(direction1 + direction2, 6); } /** * @author kcf */ - export function exportieren(richtung : typ_richtung) : int + export function export_(direction : type_direction) : int { - return richtung; + return direction; } /** * @author kcf */ - export function importieren(richtung_ : int) : typ_richtung + export function import_(direction_ : int) : type_direction { - return richtung_; + return direction_; } } diff --git a/quelldatein/aufbau/stelle.ts b/quelldatein/aufbau/stelle.ts index 5a22190..6fc7bf0 100644 --- a/quelldatein/aufbau/stelle.ts +++ b/quelldatein/aufbau/stelle.ts @@ -19,31 +19,31 @@ module mod_vtm { - export module mod_aufbau + export module mod_model { - export module mod_stelle + export module mod_spot { /** * @author kcf */ - export type typ_stelle = {u : int; v : int;}; + export type type_spot = {u : int; v : int;}; /** * @author kcf */ - export function hash(stelle : typ_stelle) : string + export function hash(spot : type_spot) : string { - return (stelle.u.toFixed(0) + "_" + stelle.v.toFixed(0)); + return (spot.u.toFixed(0) + "_" + spot.v.toFixed(0)); } /** * @author kcf */ - export function von_hash(hash : string) : typ_stelle + export function von_hash(hash : string) : type_spot { let teile : Array = hash.split("_"); return {"u": parseInt(teile[0]), "v": parseInt(teile[1])}; @@ -53,7 +53,7 @@ module mod_vtm /** * @author kcf */ - export function null_() : typ_stelle + export function null_() : type_spot { return {"u": 0, "v": 0}; } @@ -62,9 +62,9 @@ module mod_vtm /** * @author kcf */ - export function von_richtung(richtung : mod_richtung.typ_richtung) : typ_stelle + export function von_direction(direction : mod_direction.type_direction) : type_spot { - switch (richtung) + switch (direction) { case 0: {return {"u": +1, "v": 0}; break;} case 1: {return {"u": +1, "v": +1}; break;} @@ -72,7 +72,7 @@ module mod_vtm 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;} + default: {throw (new Error("ungültige Richtung '" + String(direction) + "'")); break;} } } @@ -80,27 +80,27 @@ module mod_vtm /** * @author kcf */ - export function addieren(stelle1 : typ_stelle, stelle2 : typ_stelle) : typ_stelle + export function add(spot1 : type_spot, spot2 : type_spot) : type_spot { - return {"u": (stelle1.u + stelle2.u), "v": (stelle1.v + stelle2.v)}; + return {"u": (spot1.u + spot2.u), "v": (spot1.v + spot2.v)}; } /** * @author kcf */ - export function exportieren(stelle : typ_stelle) : string + export function export_(spot : type_spot) : string { - return hash(stelle); + return hash(spot); } /** * @author kcf */ - export function importieren(stelle_ : string) : typ_stelle + export function import_(spot_ : string) : type_spot { - return von_hash(stelle_); + return von_hash(spot_); } } diff --git a/quelldatein/aufbau/symbol.ts b/quelldatein/aufbau/symbol.ts index 1a70e1b..7464e8d 100644 --- a/quelldatein/aufbau/symbol.ts +++ b/quelldatein/aufbau/symbol.ts @@ -19,7 +19,7 @@ module mod_vtm { - export module mod_aufbau + export module mod_model { export module mod_symbol @@ -28,13 +28,13 @@ module mod_vtm /** * @author kcf */ - export type typ_symbol = int; + export type type_symbol = int; /** * @author kcf */ - export function vergleichen(symbol1 : typ_symbol, symbol2 : typ_symbol) : boolean + export function vergleichen(symbol1 : type_symbol, symbol2 : type_symbol) : boolean { return (symbol1 === symbol2); } @@ -43,7 +43,7 @@ module mod_vtm /** * @author kcf */ - export function exportieren(symbol : typ_symbol) : int + export function export_(symbol : type_symbol) : int { return symbol; } @@ -52,7 +52,7 @@ module mod_vtm /** * @author kcf */ - export function importieren(symbol_ : int) : typ_symbol + export function import_(symbol_ : int) : type_symbol { return symbol_; } diff --git a/quelldatein/aufbau/welt.ts b/quelldatein/aufbau/welt.ts index dc307a9..df16feb 100644 --- a/quelldatein/aufbau/welt.ts +++ b/quelldatein/aufbau/welt.ts @@ -19,18 +19,18 @@ module mod_vtm { - export module mod_aufbau + export module mod_model { - export module mod_welt + export module mod_world { /** * @author kcf */ - export type typ_welt = + export type type_world = { - felder : lib_hashmap.typ_hashmap; + tiles : lib_hashmap.type_hashmap; } ; @@ -38,14 +38,14 @@ module mod_vtm /** * @author kcf */ - export function erstellen + export function create ( - felder : lib_hashmap.typ_hashmap = lib_hashmap.erstellen(mod_stelle.hash) + tiles : lib_hashmap.type_hashmap = lib_hashmap.create(mod_spot.hash) ) - : typ_welt + : type_world { return { - "felder": felder, + "tiles": tiles, }; } @@ -53,86 +53,86 @@ module mod_vtm /** * @author kcf */ - export function felder_lesen + export function tiles_read ( - welt : typ_welt + world : type_world ) - : Array<{stelle : mod_stelle.typ_stelle; aktor : mod_aktor.typ_aktor;}> + : Array<{spot : mod_spot.type_spot; actuator : mod_actuator.type_actuator;}> { - let felder : Array<{stelle : mod_stelle.typ_stelle; aktor : mod_aktor.typ_aktor;}> = []; - lib_hashmap.iterieren + let tiles : Array<{spot : mod_spot.type_spot; actuator : mod_actuator.type_actuator;}> = []; + lib_hashmap.iterate ( - welt.felder, - (stelle, aktor) => felder.push({"stelle": stelle, "aktor": aktor}) + world.tiles, + (spot, actuator) => tiles.push({"spot": spot, "actuator": actuator}) ) ; - return felder; + return tiles; } /** * @author kcf */ - export function feld_holen + export function tile_get ( - welt : typ_welt, - stelle : mod_stelle.typ_stelle + world : type_world, + spot : mod_spot.type_spot ) - : lib_fehlermonade.typ_fehlermonade + : lib_errormonade.type_errormonade { - return lib_hashmap.holen(welt.felder, stelle); + return lib_hashmap.get(world.tiles, spot); } /** * @author kcf */ - export function feld_setzen + export function tile_set ( - welt : typ_welt, - stelle : mod_stelle.typ_stelle, - aktor : mod_aktor.typ_aktor + world : type_world, + spot : mod_spot.type_spot, + actuator : mod_actuator.type_actuator ) : void { - lib_hashmap.setzen(welt.felder, stelle, aktor); + lib_hashmap.set(world.tiles, spot, actuator); } /** * @author kcf */ - export function feld_wechseln + export function tile_wechseln ( - welt : typ_welt, - stelle : mod_stelle.typ_stelle, + world : type_world, + spot : mod_spot.type_spot, umgekehrt : boolean = false ) : void { let erweitert : boolean = true; - let liste : Array<{pruefer : (aktor : mod_aktor.typ_aktor)=>boolean; ersteller : ()=>mod_aktor.typ_aktor;}> = ( + let liste : Array<{pruefer : (actuator : mod_actuator.type_actuator)=>boolean; erspotr : ()=>mod_actuator.type_actuator;}> = ( [] .concat ( [ { - "pruefer": (aktor) => (aktor.art === "befoerderer"), - "ersteller": () => mod_aktor.mod_befoerderer.erstellen_aktor(0), + "pruefer": (actuator) => (actuator.kind === "befoerderer"), + "erspotr": () => mod_actuator.mod_befoerderer.create_actuator(0), }, ] ) .concat ( - mod_vtm.mod_helfer.sequenz(erweitert ? 4 : 2).map + mod_vtm.mod_helfer.sequence(erweitert ? 4 : 2).map ( symbol => ( { - "pruefer": (aktor) => + "pruefer": (actuator) => { - if (aktor.art === "schreiber") + if (actuator.kind === "schreiber") { - return (mod_aktor.mod_schreiber.symbol_lesen(aktor.angaben) === symbol); + return (mod_actuator.mod_schreiber.symbol_read(actuator.data) === symbol); } else { @@ -140,29 +140,29 @@ module mod_vtm } } , - "ersteller": () => mod_aktor.mod_schreiber.erstellen_aktor(0, symbol) + "erspotr": () => mod_actuator.mod_schreiber.create_actuator(0, symbol) } ) ) ) .concat ( - mod_vtm.mod_helfer.sequenz(erweitert ? 2 : 1).map + mod_vtm.mod_helfer.sequence(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); + let symbol_links : mod_symbol.type_symbol = (2*index+0); + let symbol_rechts : mod_symbol.type_symbol = (2*index+1); return ( { - "pruefer": (aktor) => + "pruefer": (actuator) => { - if (aktor.art === "leser") + if (actuator.kind === "leser") { return ( - (mod_aktor.mod_leser.symbol_links_lesen(aktor.angaben) === symbol_links) + (mod_actuator.mod_leser.symbol_links_read(actuator.data) === symbol_links) && - (mod_aktor.mod_leser.symbol_rechts_lesen(aktor.angaben) === symbol_rechts) + (mod_actuator.mod_leser.symbol_rechts_read(actuator.data) === symbol_rechts) ); } else @@ -171,7 +171,7 @@ module mod_vtm } } , - "ersteller": () => mod_aktor.mod_leser.erstellen_aktor(0, symbol_links, symbol_rechts) + "erspotr": () => mod_actuator.mod_leser.create_actuator(0, symbol_links, symbol_rechts) } ); } @@ -181,25 +181,25 @@ module mod_vtm ( [ { - "pruefer": (aktor) => (aktor.art === "verwerfer"), - "ersteller": () => mod_aktor.mod_verwerfer.erstellen_aktor(), + "pruefer": (actuator) => (actuator.kind === "verwerfer"), + "erspotr": () => mod_actuator.mod_verwerfer.create_actuator(), }, ] ) ); - let index_alt : lib_fehlermonade.typ_fehlermonade; - let aktor_alt_ : lib_fehlermonade.typ_fehlermonade = lib_hashmap.holen(welt.felder, stelle); - if (lib_fehlermonade.voll(aktor_alt_)) + let index_alt : lib_errormonade.type_errormonade; + let actuator_alt_ : lib_errormonade.type_errormonade = lib_hashmap.get(world.tiles, spot); + if (lib_errormonade.filled(actuator_alt_)) { - let aktor_alt : mod_aktor.typ_aktor = lib_fehlermonade.lesen(aktor_alt_); + let actuator_alt : mod_actuator.type_actuator = lib_errormonade.read(actuator_alt_); let gefunden : boolean = ( liste.some ( (eintrag, index) => { - if (eintrag.pruefer(aktor_alt)) + if (eintrag.pruefer(actuator_alt)) { - index_alt = (lib_fehlermonade.erstellen_schlicht(index)); + index_alt = (lib_errormonade.create_just(index)); return true; } else @@ -211,30 +211,30 @@ module mod_vtm ); if (! gefunden) { - index_alt = (lib_fehlermonade.erstellen_nichts()); + index_alt = (lib_errormonade.create_nothing()); } else { - // nichts tun + // nothing tun } } else { - let meldung : string = "kein Aktor gesetzt"; - // console.warn(meldung); - index_alt = (lib_fehlermonade.erstellen_schlicht(0)); + let message : string = "kein Aktor gesetzt"; + // console.warn(message); + index_alt = (lib_errormonade.create_just(0)); } - if (lib_fehlermonade.voll(index_alt)) + if (lib_errormonade.filled(index_alt)) { - let index_neu : int = lib_mathematik.mod(lib_fehlermonade.lesen(index_alt) + (umgekehrt ? -1 : +1), liste.length); - let aktor_neu : mod_aktor.typ_aktor = liste[index_neu].ersteller(); - feld_setzen(welt, stelle, aktor_neu); + let index_neu : int = lib_math.mod(lib_errormonade.read(index_alt) + (umgekehrt ? -1 : +1), liste.length); + let actuator_neu : mod_actuator.type_actuator = liste[index_neu].erspotr(); + tile_set(world, spot, actuator_neu); } else { - let meldung : string = ("Aktor nicht gefunden"); - // throw (new Error(meldung)); - console.warn(meldung); + let message : string = ("Aktor nicht gefunden"); + // throw (new Error(message)); + console.warn(message); } } @@ -242,18 +242,18 @@ module mod_vtm /** * @author kcf */ - export function feld_drehen + export function tile_rotate ( - welt : typ_welt, - stelle : mod_stelle.typ_stelle, + world : type_world, + spot : mod_spot.type_spot, inkrement : int = +1 ) : void { - let aktor_ : lib_fehlermonade.typ_fehlermonade = lib_hashmap.holen(welt.felder, stelle); - if (lib_fehlermonade.voll(aktor_)) + let actuator_ : lib_errormonade.type_errormonade = lib_hashmap.get(world.tiles, spot); + if (lib_errormonade.filled(actuator_)) { - mod_aktor.drehen(lib_fehlermonade.lesen(aktor_), inkrement); + mod_actuator.rotate(lib_errormonade.read(actuator_), inkrement); } else { @@ -268,39 +268,39 @@ module mod_vtm */ export function erzeuger_finden ( - welt : typ_welt + world : type_world ) - : mod_stelle.typ_stelle + : mod_spot.type_spot { - let stelle : lib_fehlermonade.typ_fehlermonade = (lib_fehlermonade.erstellen_nichts()); - lib_hashmap.iterieren + let spot : lib_errormonade.type_errormonade = (lib_errormonade.create_nothing()); + lib_hashmap.iterate ( - welt.felder, - (stelle_, aktor) => + world.tiles, + (spot_, actuator) => { - if (aktor.art === "erzeuger") + if (actuator.kind === "erzeuger") { - if (lib_fehlermonade.voll(stelle)) + if (lib_errormonade.filled(spot)) { - let meldung : string = "mehrere Erzeuger gefunden"; - throw (new Error(meldung)); + let message : string = "mehrere Erzeuger gefunden"; + throw (new Error(message)); } else { - stelle = (lib_fehlermonade.erstellen_schlicht(stelle_)); + spot = (lib_errormonade.create_just(spot_)); } } } ) ; - if (lib_fehlermonade.voll(stelle)) + if (lib_errormonade.filled(spot)) { - return lib_fehlermonade.lesen(stelle); + return lib_errormonade.read(spot); } else { - let meldung : string = "kein Erzeuger gefunden"; - throw (new Error(meldung)); + let message : string = "kein Erzeuger gefunden"; + throw (new Error(message)); } } @@ -312,84 +312,84 @@ module mod_vtm ( groesse : int = 3 ) - : typ_welt + : type_world { - let welt : typ_welt = erstellen(); + let world : type_world = create(); 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; + let spot : mod_spot.type_spot = {"u": u, "v": v}; + let actuator : mod_actuator.type_actuator; if ((u === -groesse) && (v === 0)) { - aktor = mod_aktor.mod_erzeuger.erstellen_aktor(0); + actuator = mod_actuator.mod_erzeuger.create_actuator(0); } else if ((u === +groesse) && (v === 0)) { - aktor = mod_aktor.mod_annehmer.erstellen_aktor(); + actuator = mod_actuator.mod_annehmer.create_actuator(); } else { - aktor = mod_aktor.mod_verwerfer.erstellen_aktor(); + actuator = mod_actuator.mod_verwerfer.create_actuator(); } - lib_hashmap.setzen(welt.felder, stelle, aktor); + lib_hashmap.set(world.tiles, spot, actuator); } } } - return welt; + return world; } /** * @author kcf */ - export function exportieren + export function export_ ( - welt : typ_welt + world : type_world ) : any { - let roh : any = {}; - roh["felder"] = {}; - lib_hashmap.iterieren + let raw : any = {}; + raw["tiles"] = {}; + lib_hashmap.iterate ( - welt.felder, - (stelle, aktor) => + world.tiles, + (spot, actuator) => { - let stelle_ : string = mod_stelle.exportieren(stelle); - let aktor_ : any = mod_aktor.exportieren(aktor); - roh["felder"][stelle_] = aktor_; + let spot_ : string = mod_spot.export_(spot); + let actuator_ : any = mod_actuator.export_(actuator); + raw["tiles"][spot_] = actuator_; } ) ; - return roh; + return raw; } /** * @author kcf */ - export function importieren + export function import_ ( - roh : any + raw : any ) - : typ_welt + : type_world { - let felder : lib_hashmap.typ_hashmap = (lib_hashmap.erstellen(mod_stelle.hash)); - for (let stelle_ in roh["felder"]) + let tiles : lib_hashmap.type_hashmap = (lib_hashmap.create(mod_spot.hash)); + for (let spot_ in raw["tiles"]) { - 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_); - lib_hashmap.setzen(felder, stelle, aktor); + let spot : mod_spot.type_spot = mod_spot.import_(spot_); + let actuator_ : mod_actuator.type_actuator = raw["tiles"][spot_]; + let actuator : mod_actuator.type_actuator = mod_actuator.import_(actuator_); + lib_hashmap.set(tiles, spot, actuator); } return ( - erstellen + create ( - felder + tiles ) ); } diff --git a/quelldatein/aufbau/zustand.ts b/quelldatein/aufbau/zustand.ts index 456464f..ab1bef9 100644 --- a/quelldatein/aufbau/zustand.ts +++ b/quelldatein/aufbau/zustand.ts @@ -19,24 +19,24 @@ module mod_vtm { - export module mod_aufbau + export module mod_model { - export module mod_zustand + export module mod_state { /** * @author kcf */ - export type typ_zustand = int; + export type type_state = int; /** * @author kcf */ - export var abgelehnt = -1; - export var laufend = 0; - export var angenommen = +1; + export var rejected = -1; + export var running = 0; + export var accepted = +1; } diff --git a/quelldatein/daten.ts b/quelldatein/daten.ts index 42a644a..80421b5 100644 --- a/quelldatein/daten.ts +++ b/quelldatein/daten.ts @@ -19,36 +19,36 @@ module mod_vtm { - export module mod_daten + export module mod_data { /** * @author kcf */ - var _speicher = {}; + var _store = {}; /** * @author kcf */ - export function schreiben(schluessel : string, wert : any) : void + export function write(key : string, value : any) : void { - _speicher[schluessel] = wert; + _store[key] = value; } /** * @author kcf */ - export function lesen(schluessel : string) : lib_fehlermonade.typ_fehlermonade + export function read(key : string) : lib_errormonade.type_errormonade { - if (schluessel in _speicher) + if (key in _store) { - return (lib_fehlermonade.erstellen_schlicht(_speicher[schluessel])); + return (lib_errormonade.create_just(_store[key])); } else { - return (lib_fehlermonade.erstellen_nichts()); + return (lib_errormonade.create_nothing()); } } @@ -60,8 +60,8 @@ module mod_vtm /** * @author kcf */ -function jsonp_behandlung(objekt : {schluessel : string; wert : any;}) : void +function jsonp_handle(objekt : {key : string; value : any;}) : void { - mod_vtm.mod_daten.schreiben(objekt.schluessel, objekt.wert); + mod_vtm.mod_data.write(objekt.key, objekt.value); } diff --git a/quelldatein/daten/aufgaben.dat.js b/quelldatein/daten/aufgaben.dat.js index f45a867..cb22498 100644 --- a/quelldatein/daten/aufgaben.dat.js +++ b/quelldatein/daten/aufgaben.dat.js @@ -1,253 +1,253 @@ -jsonp_behandlung( +jsonp_handle( { - "schluessel": "aufgaben", - "wert": [ + "key": "tasks", + "value": [ { "id": "einfuehrung", - "art": "akzeptor", + "kind": "acceptor", "parameter": { "titel": "Einführung", "text": "Bewege die Figur vom Eingang (links) zum Ausgang (rechts)!", "tests": [ { - "eingabe": [], - "annehmen": true + "input": [], + "accept": true } ] } }, { "id": "start_symbol", - "art": "akzeptor", + "kind": "acceptor", "parameter": { "titel": "Start-Symbol", - "text": "Annehmen, wenn die Eingabe mit ${s1} beginnt; andernfalls ablehnen", + "text": "Annehmen, wenn die input mit ${s1} beginnt; andernfalls ablehnen", "tests": [ { - "eingabe": [], - "annehmen": false + "input": [], + "accept": false }, { - "eingabe": [0], - "annehmen": false + "input": [0], + "accept": false }, { - "eingabe": [1], - "annehmen": true + "input": [1], + "accept": true }, { - "eingabe": [0,1], - "annehmen": false + "input": [0,1], + "accept": false }, { - "eingabe": [1,0,1,1,0,0,0,1,0], - "annehmen": true + "input": [1,0,1,1,0,0,0,1,0], + "accept": true } ] } }, { "id": "dreifaltigkeit", - "art": "akzeptor", + "kind": "acceptor", "parameter": { "titel": "Dreifaltigkeit", - "text": "Annehmen genau dann, wenn die Eingabe mindestens drei ${s1} enthält", + "text": "Annehmen genau dann, wenn die input mindestens drei ${s1} enthält", "tests": [ { - "eingabe": [1], - "annehmen": false + "input": [1], + "accept": false }, { - "eingabe": [0,0,1,1], - "annehmen": false + "input": [0,0,1,1], + "accept": false }, { - "eingabe": [1,0,1,0,0,1,0], - "annehmen": true + "input": [1,0,1,0,0,1,0], + "accept": true } ] } }, { "id": "abwechslung_erfreuet", - "art": "akzeptor", + "kind": "acceptor", "parameter": { "titel": "Abwechslung erfreuet", - "text": "annehmen genau dann wenn: Die Farben der Eingabe (${s0} / ${s1}) sich immer abwechseln", + "text": "annehmen genau dann wenn: Die Farben der input (${s0} / ${s1}) sich immer abwechseln", "tests": [ { - "eingabe": [], - "annehmen": true + "input": [], + "accept": true }, { - "eingabe": [0], - "annehmen": true + "input": [0], + "accept": true }, { - "eingabe": [0,0], - "annehmen": false + "input": [0,0], + "accept": false }, { - "eingabe": [1,0,1], - "annehmen": true + "input": [1,0,1], + "accept": true }, { - "eingabe": [0,1,0,1,0,1], - "annehmen": true + "input": [0,1,0,1,0,1], + "accept": true } ] } }, { "id": "ans_ende", - "art": "transduktor", + "kind": "transductor", "parameter": { "titel": "Ans Ende", - "text": "die Eingabe (${s0} / ${s1}), aber mit dem ersten Symbol am Ende", + "text": "die input (${s0} / ${s1}), aber mit dem ersten Symbol am Ende", "tests": [ { - "eingabe": [0,0,1,1,1,0,1,0,1,1,1,0,1], - "ausgabe": [0,1,1,1,0,1,0,1,1,1,0,1,0] + "input": [0,0,1,1,1,0,1,0,1,1,1,0,1], + "output": [0,1,1,1,0,1,0,1,1,1,0,1,0] } ] } }, { "id": "tauschen", - "art": "transduktor", + "kind": "transductor", "parameter": { "titel": "Tauschen", - "text": "aus der Eingabe (${s0} / ${s1}) alle ${s0} durch ${s2} ersetzen und alle ${s1} durch ${s3}", + "text": "aus der input (${s0} / ${s1}) alle ${s0} durch ${s2} ersetzen und alle ${s1} durch ${s3}", "tests": [ { - "eingabe": [0,1,1,0], - "ausgabe": [2,3,3,2] + "input": [0,1,1,0], + "output": [2,3,3,2] }, { - "eingabe": [0,1,0,1,0,1,1,0,0,0,0,1,0,1,1,0], - "ausgabe": [2,3,2,3,2,3,3,2,2,2,2,3,2,3,3,2] + "input": [0,1,0,1,0,1,1,0,0,0,0,1,0,1,1,0], + "output": [2,3,2,3,2,3,3,2,2,2,2,3,2,3,3,2] } ] } }, { "id": "waehlerisch", - "art": "transduktor", + "kind": "transductor", "parameter": { "titel": "Wählerisch", - "text": "aus der Eingabe alle ${s0} entfernen und alle ${s1} beibehalten", + "text": "aus der input alle ${s0} entfernen und alle ${s1} beibehalten", "tests": [ { - "eingabe": [0,0,0,1,0], - "ausgabe": [1] + "input": [0,0,0,1,0], + "output": [1] }, { - "eingabe": [1,0,1,0,1], - "ausgabe": [1,1,1] + "input": [1,0,1,0,1], + "output": [1,1,1] }, { - "eingabe": [1,1,1,1,0], - "ausgabe": [1,1,1,1] + "input": [1,1,1,1,0], + "output": [1,1,1,1] }, { - "eingabe": [0,0,0,0,1,0,1,1,0], - "ausgabe": [1,1,1] + "input": [0,0,0,0,1,0,1,1,0], + "output": [1,1,1] }, ] } }, { "id": "dekorator", - "art": "transduktor", + "kind": "transductor", "parameter": { "titel": "Dekorator", "text": "Alles wird hübscher mit Schnörkeln, Schleifchen und Kinkerlitzchen aller Art! Zumindest glauben das die Leute … Shopping-Sender im Fernsehen sind der Beweis! Ob das auch für das Band der Figur gilt, wenn es nur ${s0} und ${s1} enthält? Finden wir's raus: Setz ein ${s2} an den Anfang und ein ${s3} an das Ende!", "tests": [ { - "eingabe": [1,1,0], - "ausgabe": [2,1,1,0,3] + "input": [1,1,0], + "output": [2,1,1,0,3] }, { - "eingabe": [0,0,1,0,0], - "ausgabe": [2,0,0,1,0,0,3] + "input": [0,0,1,0,0], + "output": [2,0,0,1,0,0,3] } ] } }, { "id": "alpha_und_omega", - "art": "akzeptor", + "kind": "acceptor", "parameter": { "titel": "Alpha und Omega", - "text": "Eingaben (${s0} / ${s1}), die mit den gleichen Symbolen anfangen und enden", + "text": "inputn (${s0} / ${s1}), die mit den gleichen Symbolen anfangen und enden", "tests": [ { - "eingabe": [], - "annehmen": true + "input": [], + "accept": true }, { - "eingabe": [1], - "annehmen": true + "input": [1], + "accept": true }, { - "eingabe": [0,1], - "annehmen": false + "input": [0,1], + "accept": false }, { - "eingabe": [0,1,1,1,0], - "annehmen": true + "input": [0,1,1,1,0], + "accept": true }, { - "eingabe": [1,1,0,0], - "annehmen": false + "input": [1,1,0,0], + "accept": false }, { - "eingabe": [1,0,1,1,1], - "annehmen": true + "input": [1,0,1,1,1], + "accept": true } ] } }, { "id": "an_den_anfang", - "art": "transduktor", + "kind": "transductor", "parameter": { "titel": "An den Anfang", - "text": "die Eingabe (${s0} / ${s1}), aber mit dem letzten Symbol am Anfang", + "text": "die input (${s0} / ${s1}), aber mit dem letzten Symbol am Anfang", "tests": [ { - "eingabe": [0,0,1,1,1,0,1,0,1,1,1,0,1], - "ausgabe": [1,0,0,1,1,1,0,1,0,1,1,1,0] + "input": [0,0,1,1,1,0,1,0,1,1,1,0,1], + "output": [1,0,0,1,1,1,0,1,0,1,1,1,0] } ] } }, { "id": "a_n_b_n", - "art": "akzeptor", + "kind": "acceptor", "parameter": { "titel": "a^n b^n", "text": "Jaja, die berühmt berüchtige Sprache, die sich mit einem endlichen Automaten nicht erkennen lässt … Das ist deine Chance zu zeigen, dass dieses Ding hier mehr ist als so ein kümmerlicher DEA … und das ganz ohne Kellerspeicher! Also: Eine beliebige Anzahl an ${s0}, dann die gleiche Anzahl an ${s1}!", "tests": [ { - "eingabe": [], - "annehmen": true + "input": [], + "accept": true }, { - "eingabe": [0], - "annehmen": false + "input": [0], + "accept": false }, { - "eingabe": [0,0,1,1], - "annehmen": true + "input": [0,0,1,1], + "accept": true }, { - "eingabe": [0,0,0,1,1], - "annehmen": false + "input": [0,0,0,1,1], + "accept": false }, { - "eingabe": [0,0,0,0,0,0,0,1,1,1,1,1,1,1], - "annehmen": true + "input": [0,0,0,0,0,0,0,1,1,1,1,1,1,1], + "accept": true } ], "hinweise": [ diff --git a/quelldatein/daten/zeichenketten/de.dat.js b/quelldatein/daten/zeichenketten/de.dat.js index 3e53a9d..28c1c5a 100644 --- a/quelldatein/daten/zeichenketten/de.dat.js +++ b/quelldatein/daten/zeichenketten/de.dat.js @@ -1,50 +1,54 @@ -jsonp_behandlung( +jsonp_handle( { - "schluessel": "zeichenketten-de", - "wert": { - "allgemein.titel": "Verrückte Turing-Maschinen", - "allgemein.hilfe": "Hilfe", - "allgemein.spiel": "Spiel", - "aufbau.figur.worter.singular": "Figur", - "aufbau.figur.worter.plural": "Figuren", - "aufbau.aktoren.woerter.singular": "Aktor", - "aufbau.aktoren.woerter.plural": "Aktoren", - "aufbau.aktoren.arten.erzeuger.name": "Eingang", - "aufbau.aktoren.arten.annehmer.name": "Ausgang", - "aufbau.aktoren.arten.verwerfer.name": "Abweiser", - "aufbau.aktoren.arten.befoerderer.name": "Schieber", - "aufbau.aktoren.arten.schreiber.name": "Schreiber", - "aufbau.aktoren.arten.leser.name": "Weiche", - "aufbau.aufgaben.woerter.singular": "Aufgabe", - "aufbau.aufgaben.woerter.plural": "Aufgaben", - "aufbau.aufgaben.arten.akzeptor.name": "Akzeptor", - "aufbau.aufgaben.arten.akzeptor.kuerzel": "AKZ", - "aufbau.aufgaben.arten.transduktor.name": "Transduktor", - "aufbau.aufgaben.arten.transduktor.kuerzel": "TRA", - "steuerung.auswaehlen": "Aufgabe auswählen", - "steuerung.schritt": "Nächster Schritt", - "steuerung.test": "Ablaufen", - "steuerung.anhalten": "Anhalten", - "steuerung.bearbeiten": "Bearbeiten", - "steuerung.leeren": "Leeren", - "hilfe.einleitung": "Dieses Spiel ist inspiriert von !var:manufacturia, !var:crazy_machines, !var:world_of_goo … und auch von unvergessenen Stunden Hardware-Praktikum im Informatik-Studium :P", - "hilfe.steuerung.titel": "Steuerung", - "hilfe.steuerung.eintrag1": "Links-Klick/Rechts-Klick: Feldtyp wechseln", - "hilfe.steuerung.eintrag2": "Mausrad-Drehen: Feld drehen", - "hilfe.figur.satz1": "Die Figur kann durch Aktoren auf dem Spielplan umher bewegt werden und wird als schwarzer Kreis dargestellt.", - "hilfe.figur.satz2": "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).", - "hilfe.aktoren.einleitung": "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:", - "hilfe.aktoren.erzeuger": "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.", - "hilfe.aktoren.annehmer": "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.", - "hilfe.aktoren.verwerfer": "Jedes leere Feld beendet den Lauf der Figur mit einer Abweisung des aktuellen Band-Inhalts.", - "hilfe.aktoren.befoerderer": "Dieser Aktor dient dazu die Figur von einem Feld zu einem benachbarten zu befördern ohne dabei den Band-Inhalt zu ändern.", - "hilfe.aktoren.schreiber": "Um ein Symbol auf das 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.", - "hilfe.aktoren.leser": "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.", - "hilfe.aufgaben.einleitung": "Ziel ist das Lösen von bestimmten Aufgaben. Dabei wird zwischen zwei Arten von Aufgaben unterschieden:", - "hilfe.aufgaben.akzeptor.erklaerung": "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.", - "hilfe.aufgaben.akzeptor.beispiel": "Beispiel: Genau dann akzeptieren, wenn das Band mindestens zwei mal rot enthält.", - "hilfe.aufgaben.transduktor.erklaerung": "Bei einer Transduktor-Aufgabe soll eine Ausgabe erzeugt werden, die in einer bestimmten Beziehung zur vorgefundenen Eingabe steht, also sozusagen eine Funktion angewendet werden.", - "hilfe.aufgaben.transduktor.beispiel": "Beispiel: Die Eingabe zwei mal wiederholt." + "key": "strings-de", + "value": { + "common.title": "Verrückte Turing-Maschinen", + "common.help": "Hilfe", + "common.game": "Spiel", + "model.token.terms.singular": "Figur", + "model.token.terms.plural": "Figuren", + "model.modes.initial": "Maschine bearbeiten", + "model.modes.uncertain": "wird geprüft …", + "model.modes.wrong": "fehlerhaft :/", + "model.modes.correct": "anscheinend korrekt :)", + "model.actuators.terms.singular": "Aktor", + "model.actuators.terms.plural": "Aktoren", + "model.actuators.kinds.erzeuger.name": "Eingang", + "model.actuators.kinds.annehmer.name": "Ausgang", + "model.actuators.kinds.verwerfer.name": "Abweiser", + "model.actuators.kinds.befoerderer.name": "Schieber", + "model.actuators.kinds.schreiber.name": "Schreiber", + "model.actuators.kinds.leser.name": "Weiche", + "model.tasks.terms.singular": "Aufgabe", + "model.tasks.terms.plural": "tasks", + "model.tasks.kinds.acceptor.name": "Akzeptor", + "model.tasks.kinds.acceptor.shortcut": "AKZ", + "model.tasks.kinds.transductor.name": "Transduktor", + "model.tasks.kinds.transductor.shortcut": "TRA", + "controls.choose": "Aufgabe auswählen", + "controls.step": "Nächster Schritt", + "controls.run": "Ablaufen", + "controls.stop": "Anhalten", + "controls.edit": "Bearbeiten", + "controls.clear": "Leeren", + "help.introduction": "Dieses Spiel ist inspiriert von !var:manufacturia, !var:crazy_machines, !var:world_of_goo … und auch von unvergessenen Stunden Hardware-Praktikum im Informatik-Studium :P", + "help.controls.title": "Steuerung", + "help.controls.eintrag1": "Links-Klick/Rechts-Klick: Feldtyp wechseln", + "help.controls.eintrag2": "Mausrad-Drehen: Feld drehen", + "help.token.satz1": "Die Figur kann durch Aktoren auf dem Spielplan umher bewegt werden und wird als schwarzer Kreis dargestellt.", + "help.token.satz2": "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).", + "help.actuators.introduction": "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:", + "help.actuators.erzeuger": "Der Eingang ist fest platziert auf dem ganz linken Feld des Spielplans und wird durch ein weißes Dreieck dargestellt. An ihm wird die Spieltoken auf den Plan gesetzt und bewegt sich anschließend in die angezeigte Richtung.", + "help.actuators.annehmer": "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.", + "help.actuators.verwerfer": "Jedes leere Feld beendet den Lauf der Figur mit einer Abweisung des aktuellen Band-Inhalts.", + "help.actuators.befoerderer": "Dieser Aktor dient dazu die Figur von einem Feld zu einem benachbkinds zu befördern ohne dabei den Band-Inhalt zu ändern.", + "help.actuators.schreiber": "Um ein Symbol auf das 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.", + "help.actuators.leser": "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.", + "help.tasks.introduction": "Ziel ist das Lösen von bestimmten Aufgaben. Dabei wird zwischen zwei Arten von tasks unterschieden:", + "help.tasks.acceptor.description": "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.", + "help.tasks.acceptor.example": "Beispiel: Genau dann akzeptieren, wenn das Band mindestens zwei mal rot enthält.", + "help.tasks.transductor.description": "Bei einer Transduktor-Aufgabe soll eine Ausgabe erzeugt werden, die in einer bestimmten Beziehung zur vorgefundenen Eingabe steht, also sozusagen eine Funktion angewendet werden.", + "help.tasks.transductor.example": "Beispiel: Die Eingabe zwei mal wiederholt." } } ); diff --git a/quelldatein/daten/zeichenketten/en.dat.js b/quelldatein/daten/zeichenketten/en.dat.js index 68ea6b2..91b384d 100644 --- a/quelldatein/daten/zeichenketten/en.dat.js +++ b/quelldatein/daten/zeichenketten/en.dat.js @@ -1,50 +1,54 @@ -jsonp_behandlung( +jsonp_handle( { - "schluessel": "zeichenketten-en", - "wert": { - "allgemein.titel": "Crazy Turing Machines", - "allgemein.hilfe": "Help", - "allgemein.spiel": "Game", - "aufbau.figur.worter.singular": "token", - "aufbau.figur.worter.plural": "tokens", - "aufbau.aktoren.woerter.singular": "actor", - "aufbau.aktoren.woerter.plural": "actors", - "aufbau.aktoren.arten.erzeuger.name": "entrance", - "aufbau.aktoren.arten.annehmer.name": "exit", - "aufbau.aktoren.arten.verwerfer.name": "dropper", - "aufbau.aktoren.arten.befoerderer.name": "conveyer", - "aufbau.aktoren.arten.schreiber.name": "writer", - "aufbau.aktoren.arten.leser.name": "switch", - "aufbau.aufgaben.woerter.singular": "task", - "aufbau.aufgaben.woerter.plural": "tasks", - "aufbau.aufgaben.arten.akzeptor.name": "acceptor", - "aufbau.aufgaben.arten.akzeptor.kuerzel": "ACC", - "aufbau.aufgaben.arten.transduktor.name": "transductor", - "aufbau.aufgaben.arten.transduktor.kuerzel": "TRA", - "steuerung.auswaehlen": "choose task", - "steuerung.schritt": "next step", - "steuerung.test": "run", - "steuerung.anhalten": "stop", - "steuerung.bearbeiten": "edit", - "steuerung.leeren": "clear", - "hilfe.einleitung": "This game is inspired by !var:manufacturia, !var:crazy_machines, !var:world_of_goo … and also by memorable hours of the practical hardware course during computer science study :P", - "hilfe.steuerung.titel": "controls", - "hilfe.steuerung.eintrag1": "left click/right click: change tile type", - "hilfe.steuerung.eintrag2": "rotate mousewheel: rotate tile", - "hilfe.figur.satz1": "The token can be moved around the board by actors and it is displayed as a black circle.", - "hilfe.figur.satz2": "Additionally the token has a list of set symbols (its tape), which is shown as coloured points next to the token. The tape is always read at the front and written at its back (FIFO principle).", - "hilfe.aktoren.einleitung": "Every tile on the board can be equipped with an actor, which will cause a certain effect on the token depending on the type. The following types are available:", - "hilfe.aktoren.erzeuger": "The entrance is statically placed on the most left tile of the board and is displayed as a white triangle. It is the spot at which the token is inserted into the board and moved to the indicated direction afterwards.", - "hilfe.aktoren.annehmer": "On the most right tile of the board the exit is statically placed; it is displayed as a white circle. If the token is moved to this tile, its tape content will be read and accepted.", - "hilfe.aktoren.verwerfer": "Every empty tile will cancel the tokens run with a rejection of the current tape content.", - "hilfe.aktoren.befoerderer": "This actor is used for moving the token to neighbour tile without changing the tape content.", - "hilfe.aktoren.schreiber": "In order to write a symbol to the tape, this actor is utilized. The colour indicates which symbol will be written and the direction shows to which tile the token will be moved afterwards.", - "hilfe.aktoren.leser": "At a switch the first symbol of the tape will be read and the the token will be moved the the corresponding direction. If a matching way out exists, the symbol will be removed from the tape. If no way out matches or if the tape is empty the fallback exit (grey) will be chosen.", - "hilfe.aufgaben.einleitung": "The goal is to solve certain tasks. Two kind of tasks are distinguished:", - "hilfe.aufgaben.akzeptor.erklaerung": "Here the goal is to investigate the content of the tokens tape and to decide whether it fulfils a certain condition or not. IF so, the token shall be moved to the exit; otherwise to an arbitrary empty tile.", - "hilfe.aufgaben.akzeptor.beispiel": "Example: Accept then and only then, if the tape contains at least two red symbols.", - "hilfe.aufgaben.transduktor.erklaerung": "In a transductor task an output shall be generated, which has a certain relationship to to the input; in other words: to apply a function.", - "hilfe.aufgaben.transduktor.beispiel": "Example: The input repeated two times." + "key": "strings-en", + "value": { + "common.title": "Crazy Turing Machines", + "common.help": "Help", + "common.game": "Game", + "model.token.terms.singular": "token", + "model.token.terms.plural": "tokens", + "model.modes.initial": "edit machine", + "model.modes.uncertain": "testing …", + "model.modes.wrong": "flawed :/", + "model.modes.correct": "seemingly correct :)", + "model.actuators.terms.singular": "actor", + "model.actuators.terms.plural": "actors", + "model.actuators.kinds.erzeuger.name": "entrance", + "model.actuators.kinds.annehmer.name": "exit", + "model.actuators.kinds.verwerfer.name": "dropper", + "model.actuators.kinds.befoerderer.name": "conveyer", + "model.actuators.kinds.schreiber.name": "writer", + "model.actuators.kinds.leser.name": "switch", + "model.tasks.terms.singular": "task", + "model.tasks.terms.plural": "tasks", + "model.tasks.kinds.acceptor.name": "acceptor", + "model.tasks.kinds.acceptor.shortcut": "ACC", + "model.tasks.kinds.transductor.name": "transductor", + "model.tasks.kinds.transductor.shortcut": "TRA", + "controls.choose": "choose task", + "controls.step": "next step", + "controls.run": "run", + "controls.stop": "stop", + "controls.edit": "edit", + "controls.clear": "clear", + "help.introduction": "This game is inspired by !var:manufacturia, !var:crazy_machines, !var:world_of_goo … and also by memorable hours of the practical hardware course during computer science study :P", + "help.controls.title": "controls", + "help.controls.eintrag1": "left click/right click: change tile type", + "help.controls.eintrag2": "rotate mousewheel: rotate tile", + "help.token.satz1": "The token can be moved around the board by actors and it is displayed as a black circle.", + "help.token.satz2": "Additionally the token has a list of set symbols (its tape), which is shown as coloured points next to the token. The tape is always read at the front and written at its back (FIFO principle).", + "help.actuators.introduction": "Every tile on the board can be equipped with an actor, which will cause a certain effect on the token depending on the type. The following types are available:", + "help.actuators.erzeuger": "The entrance is statically placed on the most left tile of the board and is displayed as a white triangle. It is the spot at which the token is inserted into the board and moved to the indicated direction afterwards.", + "help.actuators.annehmer": "On the most right tile of the board the exit is statically placed; it is displayed as a white circle. If the token is moved to this tile, its tape content will be read and accepted.", + "help.actuators.verwerfer": "Every empty tile will cancel the tokens run with a rejection of the current tape content.", + "help.actuators.befoerderer": "This actor is used for moving the token to neighbour tile without changing the tape content.", + "help.actuators.schreiber": "In order to write a symbol to the tape, this actor is utilized. The colour indicates which symbol will be written and the direction shows to which tile the token will be moved afterwards.", + "help.actuators.leser": "At a switch the first symbol of the tape will be read and the the token will be moved the the corresponding direction. If a matching way out exists, the symbol will be removed from the tape. If no way out matches or if the tape is empty the fallback exit (grey) will be chosen.", + "help.tasks.introduction": "The goal is to solve certain tasks. Two kind of tasks are distinguished:", + "help.tasks.acceptor.description": "Here the goal is to investigate the content of the tokens tape and to decide whether it fulfils a certain condition or not. IF so, the token shall be moved to the exit; otherwise to an arbitrary empty tile.", + "help.tasks.acceptor.example": "Example: Accept then and only then, if the tape contains at least two red symbols.", + "help.tasks.transductor.description": "In a transductor task an output shall be generated, which has a certain relationship to to the input; in other words: to apply a function.", + "help.tasks.transductor.example": "Example: The input repeated two times." } } ); diff --git a/quelldatein/haupt.ts b/quelldatein/haupt.ts index e194b73..0f3a807 100644 --- a/quelldatein/haupt.ts +++ b/quelldatein/haupt.ts @@ -22,49 +22,49 @@ module mod_vtm /** * @author kcf */ - function aufgaben_eintragen(behandler : (aufgabe : mod_aufbau.mod_aufgabe.typ_aufgabe)=>void) : void + function tasks_insert(behandler : (task : mod_model.mod_task.type_task)=>void) : void { - let aufgaben_roh_ : lib_fehlermonade.typ_fehlermonade> = mod_vtm.mod_daten.lesen("aufgaben"); - if (lib_fehlermonade.voll(aufgaben_roh_)) + let tasks_raw_ : lib_errormonade.type_errormonade> = mod_vtm.mod_data.read("tasks"); + if (lib_errormonade.filled(tasks_raw_)) { - let aufgaben_roh : Array = lib_fehlermonade.lesen(aufgaben_roh_); - let dom_auswahl : Element = document.querySelector("#aufgabe_auswahl"); - aufgaben_roh.forEach + let tasks_raw : Array = lib_errormonade.read(tasks_raw_); + let dom_selection : Element = document.querySelector("#task_selection"); + tasks_raw.forEach ( - (aufgabe_roh, index) => + (task_raw, index) => { // Aufgabe registrieren { - let aufgabe : mod_aufbau.mod_aufgabe.typ_aufgabe = mod_aufbau.mod_aufgabe.importieren(aufgabe_roh); - mod_aufbau.mod_aufgabe.registrieren(aufgabe); + let task : mod_model.mod_task.type_task = mod_model.mod_task.import_(task_raw); + mod_model.mod_task.registrieren(task); } - // Option eintragen + // Option insert { let praefix : string = ( { - "akzeptor": lib_uebersetzung.holen("aufbau.aufgaben.arten.akzeptor.kuerzel"), - "transduktor": lib_uebersetzung.holen("aufbau.aufgaben.arten.transduktor.kuerzel"), - }[aufgabe_roh["art"]] + "acceptor": lib_translate.get("model.tasks.kinds.acceptor.shortcut"), + "transductor": lib_translate.get("model.tasks.kinds.transductor.shortcut"), + }[task_raw["kind"]] ); - let titel : string = ("[" + praefix + "]" + " " + aufgabe_roh["parameter"]["titel"]); + let titel : string = ("[" + praefix + "]" + " " + task_raw["parameter"]["titel"]); let value : string = index.toFixed(0); let dom_option : Element = document.createElement("option"); dom_option.setAttribute("value", value); dom_option.textContent = titel; - dom_auswahl.appendChild(dom_option); + dom_selection.appendChild(dom_option); } } ) ; - dom_auswahl.addEventListener + dom_selection.addEventListener ( "change", event => { - let value : string = dom_auswahl["value"]; + let value : string = dom_selection["value"]; let index : int = parseInt(value); - let aufgabe : mod_aufbau.mod_aufgabe.typ_aufgabe = mod_aufbau.mod_aufgabe.holen(index); - behandler(aufgabe); + let task : mod_model.mod_task.type_task = mod_model.mod_task.get(index); + behandler(task); } ) ; @@ -79,25 +79,25 @@ module mod_vtm /** * @author kcf */ - function haupt() : void + function main() : void { // Übersetzungen { - let sprachen : Array = navigator.languages.map(sprache => sprache); - let sprache_nativ : string = "de"; - if (! sprachen[""+"includes"](sprache_nativ)) - sprachen.push(sprache_nativ); - lib_uebersetzung.einrichten(sprachen); - lib_uebersetzung.anwenden(document); + let languages : Array = navigator.languages.map(language => language); + let language_nativ : string = "de"; + if (! languages[""+"includes"](language_nativ)) + languages.push(language_nativ); + lib_translate.setup(languages); + lib_translate.deploy(document); } // Hilfe { // Einleitung { - document.querySelector("#hilfe_einleitung").innerHTML = ( - lib_uebersetzung.holen + document.querySelector("#help_introduction").innerHTML = ( + lib_translate.get ( - "hilfe.einleitung", + "help.introduction", { "manufacturia": "Manufacturia", "crazy_machines": "Crazy Machines", @@ -118,28 +118,28 @@ module mod_vtm let hoehe : float = 80; [ { - "aufbau": mod_aufbau.mod_aktor.beispiel("erzeuger"), - "bereich": document.querySelector("#hilfe_aktoren_aktor_erzeuger"), + "model": mod_model.mod_actuator.example("erzeuger"), + "bereich": document.querySelector("#help_actuators_actuator_erzeuger"), }, { - "aufbau": mod_aufbau.mod_aktor.beispiel("annehmer"), - "bereich": document.querySelector("#hilfe_aktoren_aktor_annehmer"), + "model": mod_model.mod_actuator.example("annehmer"), + "bereich": document.querySelector("#help_actuators_actuator_annehmer"), }, { - "aufbau": mod_aufbau.mod_aktor.beispiel("verwerfer"), - "bereich": document.querySelector("#hilfe_aktoren_aktor_verwerfer"), + "model": mod_model.mod_actuator.example("verwerfer"), + "bereich": document.querySelector("#help_actuators_actuator_verwerfer"), }, { - "aufbau": mod_aufbau.mod_aktor.beispiel("befoerderer"), - "bereich": document.querySelector("#hilfe_aktoren_aktor_befoerderer"), + "model": mod_model.mod_actuator.example("befoerderer"), + "bereich": document.querySelector("#help_actuators_actuator_befoerderer"), }, { - "aufbau": mod_aufbau.mod_aktor.beispiel("schreiber"), - "bereich": document.querySelector("#hilfe_aktoren_aktor_schreiber"), + "model": mod_model.mod_actuator.example("schreiber"), + "bereich": document.querySelector("#help_actuators_actuator_schreiber"), }, { - "aufbau": mod_aufbau.mod_aktor.beispiel("leser"), - "bereich": document.querySelector("#hilfe_aktoren_aktor_leser"), + "model": mod_model.mod_actuator.example("leser"), + "bereich": document.querySelector("#help_actuators_actuator_leser"), }, ] .forEach @@ -147,22 +147,22 @@ module mod_vtm eintrag => { let manifestation = ( - mod_manifestation.mod_svg.mod_aktor.erstellen_manifestation + mod_manifestation.mod_svg.mod_actuator.create_manifestation ( - eintrag.aufbau, - mod_aufbau.mod_stelle.null_() + eintrag.model, + mod_model.mod_spot.null_() ) ); - let xmlknoten : lib_xml.typ_knoten = ( - mod_manifestation.mod_svg.wurzel + let xmlnode : lib_xml.type_node = ( + mod_manifestation.mod_svg.root ( von_x, von_y, bis_x, bis_y, breite, hoehe, - [mod_manifestation.darstellen(manifestation)] + [mod_manifestation.view(manifestation)] ) ); - eintrag.bereich.querySelector(".hilfe_aktoren_aktor_bild").innerHTML = lib_xml.darstellen(xmlknoten); + eintrag.bereich.querySelector(".help_actuators_actuator_image").innerHTML = lib_xml.view(xmlnode); } ) ; @@ -171,35 +171,35 @@ module mod_vtm } // Spiel { - let partie : mod_aufbau.mod_partie.typ_partie; + let round : mod_model.mod_round.type_round; // Aufgaben { - aufgaben_eintragen + tasks_insert ( - function (aufgabe : mod_aufbau.mod_aufgabe.typ_aufgabe) : void {mod_aufbau.mod_partie.aufgabe_setzen(partie, aufgabe);} + function (task : mod_model.mod_task.type_task) : void {mod_model.mod_round.task_set(round, task);} ) ; } // Aufbau { - partie = mod_aufbau.mod_partie.erstellen(mod_aufbau.mod_aufgabe.holen(0)); + round = mod_model.mod_round.create(mod_model.mod_task.get(0)); } // Manifestationen { [ - mod_manifestation.mod_web.mod_partie.erstellen_erweitert + mod_manifestation.mod_web.mod_round.create_erweitert ( - partie, - document.querySelector("#bereich_mitte") + round, + document.querySelector("#section_mid") ) , - mod_manifestation.mod_speicher.mod_partie.erstellen_erweitert + mod_manifestation.mod_store.mod_round.create_erweitert ( - partie + round ) , ] - .forEach(mod_manifestation.einrichten); + .forEach(mod_manifestation.setup); } } } @@ -208,12 +208,12 @@ module mod_vtm /** * @author kcf */ - export function eingang_web() : void + export function entry_web() : void { document.addEventListener ( "DOMContentLoaded", - event => {haupt();} + event => {main();} ) ; } diff --git a/quelldatein/helfer/aufruf.ts b/quelldatein/helfer/aufruf.ts index fbd8ab8..1ae5e4c 100644 --- a/quelldatein/helfer/aufruf.ts +++ b/quelldatein/helfer/aufruf.ts @@ -16,56 +16,56 @@ * along with this program. If not, see . */ -module lib_aufruf +module lib_call { /** * @author kcf */ - export type typ_komplex = {art : string; angaben : typ_angaben;}; + export type type_complex = {kind : string; data : type_data;}; /** * @author kcf */ - export function einpacken(art : string, angaben : typ_angaben) : typ_komplex + export function wrap(kind : string, data : type_data) : type_complex { - return {"art": art, "angaben": angaben}; + return {"kind": kind, "data": data}; } /** * @author kcf */ - export function auspacken(komplex : typ_komplex) : typ_angaben + export function unwrap(complex : type_complex) : type_data { - return komplex.angaben; + return complex.data; } /** * @author kcf */ - export function fallunterscheidung + export function distinguish ( - komplex : typ_komplex, - faelle : {[art : string] : (angaben ?: any)=>typ_ergebnis}, - ersatz : (komplex : typ_komplex)=>typ_ergebnis = ((komplex) => {throw (new Error("unbehandelt"));}) + complex : type_complex, + cases : {[kind : string] : (data ?: any)=>type_result}, + fallback : (complex : type_complex)=>type_result = ((complex) => {throw (new Error("unbehandelt"));}) ) - : typ_ergebnis + : type_result { - if (komplex.art in faelle) + if (complex.kind in cases) { - let funktion : (angaben ?: any)=>typ_ergebnis = faelle[komplex.art]; - let ergebnis : typ_ergebnis = funktion(komplex.angaben); - return ergebnis; + let function_ : (data ?: any)=>type_result = cases[complex.kind]; + let result : type_result = function_(complex.data); + return result; } else { - let meldung : string = ("unbehandelte Art '" + komplex.art + "'"); - console.warn(meldung); - let ergebnis : typ_ergebnis = ersatz(komplex); - return ergebnis; + let message : string = ("unbehandelte Art '" + complex.kind + "'"); + console.warn(message); + let result : type_result = fallback(complex); + return result; } } } diff --git a/quelldatein/helfer/brauch.ts b/quelldatein/helfer/brauch.ts index 927910d..1788db8 100644 --- a/quelldatein/helfer/brauch.ts +++ b/quelldatein/helfer/brauch.ts @@ -17,22 +17,22 @@ */ -module lib_brauch +module lib_trait { /** * @author kcf */ - export type typ_brauch = {[domäne : string] : typ_signatur}; + export type type_trait = {[domain : string] : type_signature}; /** * @author kcf */ - export function erstellen + export function create ( ) - : typ_brauch + : type_trait { return {}; } @@ -41,22 +41,22 @@ module lib_brauch /** * @author kcf */ - export function umsetzen + export function attend ( - brauch : typ_brauch, - domaene : string, - implementierung : typ_signatur + trait : type_trait, + domain : string, + implementation : type_signature ) : void { - if (domaene in brauch) + if (domain in trait) { - let meldung : string = ("Domäne '" + domaene + "' bereits vorhanden"); - throw (new Error(meldung)); + let message : string = ("Domäne '" + domain + "' bereits vorhanden"); + throw (new Error(message)); } else { - brauch[domaene] = implementierung; + trait[domain] = implementation; } } @@ -64,21 +64,21 @@ module lib_brauch /** * @author kcf */ - export function anwenden + export function deploy ( - brauch : typ_brauch, - domaene : string + trait : type_trait, + domain : string ) - : typ_signatur + : type_signature { - if (! (domaene in brauch)) + if (! (domain in trait)) { - let meldung : string = ("keine Implementierung für Domäne '" + domaene + "' vorhanden"); - throw (new Error(meldung)); + let message : string = ("keine Implementierung für Domäne '" + domain + "' vorhanden"); + throw (new Error(message)); } else { - return brauch[domaene]; + return trait[domain]; } } diff --git a/quelldatein/helfer/fehlermonade.ts b/quelldatein/helfer/fehlermonade.ts index fae04f0..adda840 100644 --- a/quelldatein/helfer/fehlermonade.ts +++ b/quelldatein/helfer/fehlermonade.ts @@ -16,27 +16,27 @@ * along with this program. If not, see . */ -module lib_fehlermonade +module lib_errormonade { /** * @author kcf */ - export type typ_fehlermonade = lib_aufruf.typ_komplex; + export type type_errormonade = lib_call.type_complex; /** * @author kcf */ - export function erstellen_nichts + export function create_nothing ( ) - : typ_fehlermonade + : type_errormonade { return ( - lib_aufruf.einpacken + lib_call.wrap ( - "nichts", + "nothing", { } ) @@ -47,18 +47,18 @@ module lib_fehlermonade /** * @author kcf */ - export function erstellen_schlicht + export function create_just ( - wert : typ_wert + value : type_value ) - : typ_fehlermonade + : type_errormonade { return ( - lib_aufruf.einpacken + lib_call.wrap ( - "schlicht", + "just", { - "wert": wert + "value": value } ) ); @@ -68,19 +68,19 @@ module lib_fehlermonade /** * @author kcf */ - export function voll + export function filled ( - fehlermonade : typ_fehlermonade + errormonade : type_errormonade ) : boolean { return ( - lib_aufruf.fallunterscheidung + lib_call.distinguish ( - fehlermonade, + errormonade, { - "nichts": ({}) => false, - "schlicht": ({"wert": wert}) => true, + "nothing": ({}) => false, + "just": ({"value": value}) => true, } ) ); @@ -90,19 +90,19 @@ module lib_fehlermonade /** * @author kcf */ - export function lesen + export function read ( - fehlermonade : typ_fehlermonade + errormonade : type_errormonade ) - : typ_wert + : type_value { return ( - lib_aufruf.fallunterscheidung + lib_call.distinguish ( - fehlermonade, + errormonade, { - "nichts": ({}) => {throw (new Error("lesen von nichts"));}, - "schlicht": ({"wert": wert}) => wert, + "nothing": ({}) => {throw (new Error("read von nothing"));}, + "just": ({"value": value}) => value, } ) ); @@ -112,20 +112,20 @@ module lib_fehlermonade /** * @author kcf */ - export function fortfuehren + export function propagate ( - fehlermonade : typ_fehlermonade, - funktion : (wert1 : typ_wert1)=>typ_fehlermonade + errormonade : type_errormonade, + funktion : (value1 : type_value1)=>type_errormonade ) - : typ_fehlermonade + : type_errormonade { return ( - lib_aufruf.fallunterscheidung + lib_call.distinguish ( - fehlermonade, + errormonade, { - "nichts": ({}) => erstellen_nichts(), - "schlicht": ({"wert": wert1}) => funktion(wert1), + "nothing": ({}) => create_nothing(), + "just": ({"value": value1}) => funktion(value1), } ) ); diff --git a/quelldatein/helfer/hashmap.ts b/quelldatein/helfer/hashmap.ts index f3000da..c2fe862 100644 --- a/quelldatein/helfer/hashmap.ts +++ b/quelldatein/helfer/hashmap.ts @@ -22,10 +22,10 @@ module lib_hashmap /** * @author kcf */ - export type typ_hashmap = + export type type_hashmap = { - hashfunction : (schluessel : typ_schluessel)=>string; - speicher : {[hashwert : string] : {schluessel : typ_schluessel; wert : typ_wert;}}; + hashfunction : (key : type_key)=>string; + store : {[hashvalue : string] : {key : type_key; value : type_value;}}; } ; @@ -33,15 +33,15 @@ module lib_hashmap /** * @author kcf */ - export function erstellen + export function create ( - hashfunction : (schluessel : typ_schluessel)=>string + hashfunction : (key : type_key)=>string ) - : typ_hashmap + : type_hashmap { return { "hashfunction": hashfunction, - "speicher": {}, + "store": {}, }; } @@ -49,38 +49,38 @@ module lib_hashmap /** * @author kcf */ - export function setzen + export function set ( - hashmap : typ_hashmap, - schluessel : typ_schluessel, - wert : typ_wert + hashmap : type_hashmap, + key : type_key, + value : type_value ) : void { - let hashwert : string = hashmap.hashfunction(schluessel); - hashmap.speicher[hashwert] = {"schluessel": schluessel, "wert": wert}; + let hashvalue : string = hashmap.hashfunction(key); + hashmap.store[hashvalue] = {"key": key, "value": value}; } /** * @author kcf */ - export function holen + export function get ( - hashmap : typ_hashmap, - schluessel : typ_schluessel + hashmap : type_hashmap, + key : type_key ) - : lib_fehlermonade.typ_fehlermonade + : lib_errormonade.type_errormonade { - let hashwert : string = hashmap.hashfunction(schluessel); - if (hashwert in hashmap.speicher) + let hashvalue : string = hashmap.hashfunction(key); + if (hashvalue in hashmap.store) { - let wert : typ_wert = hashmap.speicher[hashwert].wert; - return (lib_fehlermonade.erstellen_schlicht(wert)); + let value : type_value = hashmap.store[hashvalue].value; + return (lib_errormonade.create_just(value)); } else { - return (lib_fehlermonade.erstellen_nichts()); + return (lib_errormonade.create_nothing()); } } @@ -88,19 +88,19 @@ module lib_hashmap /** * @author kcf */ - export function iterieren + export function iterate ( - hashmap : typ_hashmap, - prozedur : (schluessel ?: typ_schluessel, wert ?: typ_wert)=>void + hashmap : type_hashmap, + procedure : (key ?: type_key, value ?: type_value)=>void ) : void { - Object.keys(hashmap.speicher).forEach + Object.keys(hashmap.store).forEach ( - (hashwert) => + (hashvalue) => { - let paar : {schluessel : typ_schluessel; wert : typ_wert;} = hashmap.speicher[hashwert]; - prozedur(paar.schluessel, paar.wert); + let paar : {key : type_key; value : type_value;} = hashmap.store[hashvalue]; + procedure(paar.key, paar.value); } ) ; diff --git a/quelldatein/helfer/mathematik.ts b/quelldatein/helfer/mathematik.ts index 4a66bb5..d413b4a 100644 --- a/quelldatein/helfer/mathematik.ts +++ b/quelldatein/helfer/mathematik.ts @@ -16,7 +16,7 @@ * along with this program. If not, see . */ -module lib_mathematik +module lib_math { /** diff --git a/quelldatein/helfer/uebersetzung.ts b/quelldatein/helfer/uebersetzung.ts index baf7dde..2b6c18d 100644 --- a/quelldatein/helfer/uebersetzung.ts +++ b/quelldatein/helfer/uebersetzung.ts @@ -17,46 +17,46 @@ */ -module lib_uebersetzung +module lib_translate { /** * @author kcf */ - var _sprachstapel : Array; + var _languagestack : Array; /** * @author kcf */ - var _daten : {[sprache : string] : {[schluessel : string] : string}} = {}; + var _data : {[language : string] : {[key : string] : string}} = {}; /** * @author kcf */ - export function einrichten(sprachen : Array) : void + export function setup(languages : Array) : void { - _sprachstapel = []; - sprachen.forEach + _languagestack = []; + languages.forEach ( - sprache => + language => { - let zeichenketten_roh_ : lib_fehlermonade.typ_fehlermonade = mod_vtm.mod_daten.lesen("zeichenketten-" + sprache); - if (lib_fehlermonade.voll(zeichenketten_roh_)) + let strs_raw_ : lib_errormonade.type_errormonade = mod_vtm.mod_data.read("strings-" + language); + if (lib_errormonade.filled(strs_raw_)) { - let zeichenketten_roh : {[schluessel : string] : string} = (<{[schluessel : string] : string}>(lib_fehlermonade.lesen(zeichenketten_roh_))); - _daten[sprache] = {}; - for (let schluessel in zeichenketten_roh) + let strs_raw : {[key : string] : string} = (<{[key : string] : string}>(lib_errormonade.read(strs_raw_))); + _data[language] = {}; + for (let key in strs_raw) { - _daten[sprache][schluessel] = ((zeichenketten_roh[schluessel])); + _data[language][key] = ((strs_raw[key])); } - _sprachstapel.push(sprache); + _languagestack.push(language); } else { - let meldung : string = ("Zeichenketten für Sprache '" + sprache + "' konnten nicht geladen werden"); - console.warn(meldung); + let message : string = ("Zeichenketten für Sprache '" + language + "' konnten nicht geladen werden"); + console.warn(message); } } ) @@ -67,27 +67,27 @@ module lib_uebersetzung /** * @author kcf */ - function lesen(sprache : string, schluessel : string) : lib_fehlermonade.typ_fehlermonade + function read(language : string, key : string) : lib_errormonade.type_errormonade { - if (sprache in _daten) + if (language in _data) { - let satz : {[schluessel : string] : string} = _daten[sprache]; - if (schluessel in satz) + let dataset : {[key : string] : string} = _data[language]; + if (key in dataset) { - return (lib_fehlermonade.erstellen_schlicht(satz[schluessel])); + return (lib_errormonade.create_just(dataset[key])); } else { - let meldung : string = ("keine Zeichenketten für Schlüssel '" + schluessel + "' in Sprache '" + sprache + "'"); - console.warn(meldung); - return (lib_fehlermonade.erstellen_nichts()); + let message : string = ("keine Zeichenketten für Schlüssel '" + key + "' in Sprache '" + language + "'"); + console.warn(message); + return (lib_errormonade.create_nothing()); } } else { - let meldung : string = ("keine Zeichenketten für Sprache '" + sprache + "'"); - console.warn(meldung); - return (lib_fehlermonade.erstellen_nichts()); + let message : string = ("keine Zeichenketten für Sprache '" + language + "'"); + console.warn(message); + return (lib_errormonade.create_nothing()); } } @@ -95,19 +95,19 @@ module lib_uebersetzung /** * @author kcf */ - export function holen(schluessel : string, vars : {[name : string] : string} = {}) : string + export function get(key : string, vars : {[name : string] : string} = {}) : string { - let ergebnis : lib_fehlermonade.typ_fehlermonade = (lib_fehlermonade.erstellen_nichts()); - let gefunden : boolean = ( - _sprachstapel + let result : lib_errormonade.type_errormonade = (lib_errormonade.create_nothing()); + let found : boolean = ( + _languagestack .some ( - sprache => + language => { - let ergebnis_ : lib_fehlermonade.typ_fehlermonade = lesen(sprache, schluessel); - if (lib_fehlermonade.voll(ergebnis_)) + let result_ : lib_errormonade.type_errormonade = read(language, key); + if (lib_errormonade.filled(result_)) { - ergebnis = ergebnis_; + result = result_; return true; } else @@ -117,20 +117,20 @@ module lib_uebersetzung } ) ); - if (gefunden) + if (found) { - let str : string = lib_fehlermonade.lesen(ergebnis); + let str : string = lib_errormonade.read(result); for (let name in vars) { - let muster : RegExp = (new RegExp("!var:" + name)); - let wert : string = vars[name]; - str = str.replace(muster, wert); + let pattern : RegExp = (new RegExp("!var:" + name)); + let value : string = vars[name]; + str = str.replace(pattern, value); } return str; } else { - return ("{" + schluessel + "}"); + return ("{" + key + "}"); } } @@ -138,31 +138,31 @@ module lib_uebersetzung /** * @author kcf */ - export function anwenden(kontext : DocumentFragment) : void + export function deploy(context : DocumentFragment) : void { - let muster : RegExp = (new RegExp("^!translate:([a-z0-9\.]*)$")); + let pattern : RegExp = (new RegExp("^!translate:([a-z0-9\.]*)$")); document.querySelectorAll("*")[""+"forEach"] ( element => { if (element.childElementCount === 0) { - let inhalt : string = element.textContent; - let fund : any = muster.exec(inhalt); + let content : string = element.textContent; + let fund : any = pattern.exec(content); if (fund != null) { - let schluessel : string = fund[1]; - let inhalt_ : string = holen(schluessel); - element.textContent = inhalt_; + let key : string = fund[1]; + let content_ : string = get(key); + element.textContent = content_; } else { - // nichts tun + // nothing tun } } else { - // nichts tun + // nothing tun } } ) diff --git a/quelldatein/helfer/vektor.ts b/quelldatein/helfer/vektor.ts index 43deacf..0ef6519 100644 --- a/quelldatein/helfer/vektor.ts +++ b/quelldatein/helfer/vektor.ts @@ -16,39 +16,39 @@ * along with this program. If not, see . */ -module lib_vektor +module lib_vector { /** * @author kcf */ - export type typ_vektor = {x : float; y : float;}; + export type type_vector = {x : float; y : float;}; /** * @author kcf */ - export function polar(winkel : float, radius : float = 1) : typ_vektor + export function polar(angle : float, radius : float = 1) : type_vector { - return {"x": (radius * Math.cos(winkel)), "y": (radius * Math.sin(winkel))}; + return {"x": (radius * Math.cos(angle)), "y": (radius * Math.sin(angle))}; } /** * @author kcf */ - export function skalieren(vektor : typ_vektor, faktor : float) : typ_vektor + export function scale(vector : type_vector, factuator : float) : type_vector { - return {"x": (vektor.x * faktor), "y": (vektor.y * faktor)}; + return {"x": (vector.x * factuator), "y": (vector.y * factuator)}; } /** * @author kcf */ - export function addieren(vektor1 : typ_vektor, vektor2 : typ_vektor) : typ_vektor + export function add(vector1 : type_vector, vector2 : type_vector) : type_vector { - return {"x": (vektor1.x + vektor2.x), "y": (vektor1.y + vektor2.y)}; + return {"x": (vector1.x + vector2.x), "y": (vector1.y + vector2.y)}; } } diff --git a/quelldatein/helfer/verschiedenes.ts b/quelldatein/helfer/verschiedenes.ts index 45ad0d1..1c32b53 100644 --- a/quelldatein/helfer/verschiedenes.ts +++ b/quelldatein/helfer/verschiedenes.ts @@ -25,16 +25,16 @@ module mod_vtm /** * @author kcf */ - export function sequenz(laenge : int) : Array + export function sequence(laenge : int) : Array { - return ((laenge <= 0) ? [] : sequenz(laenge-1).concat([laenge-1])); + return ((laenge <= 0) ? [] : sequence(laenge-1).concat([laenge-1])); } /** * @author kcf */ - export function liste_kopieren(liste : Array, element_kopieren : (element : type_element)=>type_element = (x => x)) : Array + export function list_copy(liste : Array, element_kopieren : (element : type_element)=>type_element = (x => x)) : Array { let liste_ : Array = []; liste.forEach diff --git a/quelldatein/helfer/xml.ts b/quelldatein/helfer/xml.ts index 31d82f4..3fb617d 100644 --- a/quelldatein/helfer/xml.ts +++ b/quelldatein/helfer/xml.ts @@ -22,17 +22,17 @@ module lib_xml /** * @author kcf */ - function einrueckung + function indent ( - tiefe : int, + depth : int, zeichen : string = "\t" ) : string { return ( - (tiefe === 0) + (depth === 0) ? "" - : (zeichen + einrueckung(tiefe-1)) + : (zeichen + indent(depth-1)) ); } @@ -40,24 +40,24 @@ module lib_xml /** * @author kcf */ - export type typ_knoten = lib_aufruf.typ_komplex; + export type type_node = lib_call.type_complex; /** * @author kcf */ - export function erstellen_text + export function create_text ( - inhalt : string + content : string ) - : typ_knoten + : type_node { return ( - lib_aufruf.einpacken + lib_call.wrap ( "text", { - "inhalt": inhalt + "content": content } ) ); @@ -67,22 +67,22 @@ module lib_xml /** * @author kcf */ - export function erstellen_normal + export function create_normal ( name : string, - attribute : {[schluessel : string] : string} = {}, - kinder : Array = [] + attributes : {[key : string] : string} = {}, + children : Array = [] ) - : typ_knoten + : type_node { return ( - lib_aufruf.einpacken + lib_call.wrap ( "normal", { "name": name, - "attribute": attribute, - "kinder": kinder + "attributes": attributes, + "children": children } ) ); @@ -92,57 +92,57 @@ module lib_xml /** * @author kcf */ - export function darstellen + export function view ( - knoten : typ_knoten, - tiefe : int = 0 + node : type_node, + depth : int = 0 ) : string { return ( - lib_aufruf.fallunterscheidung + lib_call.distinguish ( - knoten, + node, { - "text": ({"inhalt": inhalt}) => + "text": ({"content": content}) => { - return inhalt; + return content; } , - "normal": ({"name": name, "attribute": attribute, "kinder": kinder}) => + "normal": ({"name": name, "attributes": attributes, "children": children}) => { let str : string = ""; - // anfang + // begin { - let str_anfang : string = ""; - str_anfang += name; - // attribute + let str_begin : string = ""; + str_begin += name; + // attributes { - let str_attribute : string = ""; - Object.keys(attribute).forEach + let str_attributes : string = ""; + Object.keys(attributes).forEach ( - schluessel => + key => { - let wert : string = attribute[schluessel]; - str_attribute += (" " + schluessel + "=" + ("\"" + wert + "\"")); + let value : string = attributes[key]; + str_attributes += (" " + key + "=" + ("\"" + value + "\"")); } ) ; - str_anfang += str_attribute; + str_begin += str_attributes; } - str_anfang = (einrueckung(tiefe) + "<" + str_anfang + ">" + "\n"); - str += str_anfang; + str_begin = (indent(depth) + "<" + str_begin + ">" + "\n"); + str += str_begin; } - // kinder + // children { - kinder.forEach(kind => (str += darstellen(kind, tiefe+1))); + children.forEach(child => (str += view(child, depth+1))); } - // ende + // end { - let str_ende : string = ""; - str_ende += name; - str_ende = (einrueckung(tiefe) + "<" + "/" + str_ende + ">" + "\n"); - str += str_ende; + let str_end : string = ""; + str_end += name; + str_end = (indent(depth) + "<" + "/" + str_end + ">" + "\n"); + str += str_end; } return str; } diff --git a/quelldatein/manifestation/manifestation.ts b/quelldatein/manifestation/manifestation.ts index 5bfc53d..d94e903 100644 --- a/quelldatein/manifestation/manifestation.ts +++ b/quelldatein/manifestation/manifestation.ts @@ -25,16 +25,16 @@ module mod_vtm /** * @author kcf */ - export type typ_manifestation = lib_aufruf.typ_komplex; + export type type_manifestation = lib_call.type_complex; /** * @author kcf */ - export type signatur_manifestation = + export type signature_manifestation = { - darstellen : (manifestation : typ_manifestation)=>typ_ausgabe; - binden : (manifestation : typ_manifestation)=>void; + view : (manifestation : type_manifestation)=>type_ausgabe; + bind : (manifestation : type_manifestation)=>void; } ; @@ -42,46 +42,46 @@ module mod_vtm /** * @author kcf */ - export var brauch_manifestation : lib_brauch.typ_brauch> = lib_brauch.erstellen>(); + export var trait_manifestation : lib_trait.type_trait> = lib_trait.create>(); /** * @author kcf */ - export function darstellen + export function view ( - manifestation : typ_manifestation + manifestation : type_manifestation ) - : typ_ausgabe + : type_ausgabe { - return lib_brauch.anwenden(brauch_manifestation, manifestation.art)["darstellen"](manifestation); + return lib_trait.deploy(trait_manifestation, manifestation.kind)["view"](manifestation); } /** * @author kcf */ - export function binden + export function bind ( - manifestation : typ_manifestation + manifestation : type_manifestation ) : void { - return lib_brauch.anwenden(brauch_manifestation, manifestation.art)["binden"](manifestation); + return lib_trait.deploy(trait_manifestation, manifestation.kind)["bind"](manifestation); } /** * @author kcf */ - export function einrichten + export function setup ( - manifestation : typ_manifestation + manifestation : type_manifestation ) : void { - darstellen(manifestation); - binden(manifestation); + view(manifestation); + bind(manifestation); } } diff --git a/quelldatein/manifestation/position.ts b/quelldatein/manifestation/position.ts index 7a59a78..32aad93 100644 --- a/quelldatein/manifestation/position.ts +++ b/quelldatein/manifestation/position.ts @@ -28,26 +28,26 @@ module mod_vtm /** * @author kcf */ - export type typ_position = lib_vektor.typ_vektor; + export type type_position = lib_vector.type_vector; /** * @author kcf */ - var basis1 : typ_position = lib_vektor.polar((0/6) * (2*Math.PI)); - var basis2 : typ_position = lib_vektor.polar((2/6) * (2*Math.PI)); + var basis1 : type_position = lib_vector.polar((0/6) * (2*Math.PI)); + var basis2 : type_position = lib_vector.polar((2/6) * (2*Math.PI)); /** * @author kcf */ - export function von_stelle(stelle : mod_vtm.mod_aufbau.mod_stelle.typ_stelle) : typ_position + export function von_spot(spot : mod_vtm.mod_model.mod_spot.type_spot) : type_position { return ( - lib_vektor.addieren + lib_vector.add ( - lib_vektor.skalieren(basis1, stelle.u), - lib_vektor.skalieren(basis2, stelle.v) + lib_vector.scale(basis1, spot.u), + lib_vector.scale(basis2, spot.v) ) ); } diff --git a/quelldatein/manifestation/speicher/partie.ts b/quelldatein/manifestation/speicher/partie.ts index 4ee98f9..1273ff0 100644 --- a/quelldatein/manifestation/speicher/partie.ts +++ b/quelldatein/manifestation/speicher/partie.ts @@ -22,18 +22,18 @@ module mod_vtm export module mod_manifestation { - export module mod_speicher + export module mod_store { - export module mod_partie + export module mod_round { /** * @author kcf */ - export type typ_partie = + export type type_round = { - aufbau : mod_vtm.mod_aufbau.mod_partie.typ_partie; + model : mod_vtm.mod_model.mod_round.type_round; } ; @@ -41,14 +41,14 @@ module mod_vtm /** * @author kcf */ - export function erstellen + export function create ( - aufbau : mod_vtm.mod_aufbau.mod_partie.typ_partie + model : mod_vtm.mod_model.mod_round.type_round ) - : typ_partie + : type_round { return { - "aufbau": aufbau + "model": model }; } @@ -56,15 +56,15 @@ module mod_vtm /** * @author kcf */ - export function erstellen_erweitert + export function create_erweitert ( - aufbau : mod_vtm.mod_aufbau.mod_partie.typ_partie + model : mod_vtm.mod_model.mod_round.type_round ) - : typ_manifestation + : type_manifestation { return { - "art": "speicher_partie", - "angaben": erstellen(aufbau) + "kind": "store_round", + "data": create(model) }; } @@ -72,7 +72,7 @@ module mod_vtm /** * @author kcf */ - function darstellen(partie : typ_partie) : void + function view(round : type_round) : void { } @@ -80,68 +80,68 @@ module mod_vtm /** * @author kcf */ - function binden(partie : typ_partie) : void + function bind(round : type_round) : void { - mod_vtm.mod_aufbau.mod_partie.lauschen + mod_vtm.mod_model.mod_round.lauschen ( - partie.aufbau, - "aenderung_aufgabe", - (angaben) => + round.model, + "aendrung_task", + (data) => { - // console.info("aenderung_aufgabe", angaben); - let aufgabe : mod_vtm.mod_aufbau.mod_aufgabe.typ_aufgabe = mod_vtm.mod_aufbau.mod_partie.aufgabe_lesen(partie.aufbau); - let id : string = mod_vtm.mod_aufbau.mod_aufgabe.id(aufgabe); + // console.info("aendrung_task", data); + let task : mod_vtm.mod_model.mod_task.type_task = mod_vtm.mod_model.mod_round.task_read(round.model); + let id : string = mod_vtm.mod_model.mod_task.id(task); let key : string = ("vtm_" + id); // if (key in localStorage) { let item : string = localStorage.getItem(key); - let welt_ : any = JSON.parse(item); - let welt : mod_vtm.mod_aufbau.mod_welt.typ_welt = mod_vtm.mod_aufbau.mod_welt.importieren(welt_); - mod_vtm.mod_aufbau.mod_partie.welt_setzen(partie.aufbau, welt, false); + let world_ : any = JSON.parse(item); + let world : mod_vtm.mod_model.mod_world.type_world = mod_vtm.mod_model.mod_world.import_(world_); + mod_vtm.mod_model.mod_round.world_set(round.model, world, false); } else { - mod_vtm.mod_aufbau.mod_partie.welt_leeren(partie.aufbau); - // nichts tun + mod_vtm.mod_model.mod_round.world_clear(round.model); + // nothing tun } } ) ; - mod_vtm.mod_aufbau.mod_partie.lauschen + mod_vtm.mod_model.mod_round.lauschen ( - partie.aufbau, - "aenderung_welt", - (angaben) => + round.model, + "aendrung_world", + (data) => { - let aufgabe : mod_vtm.mod_aufbau.mod_aufgabe.typ_aufgabe = mod_vtm.mod_aufbau.mod_partie.aufgabe_lesen(partie.aufbau); - let id : string = mod_vtm.mod_aufbau.mod_aufgabe.id(aufgabe); + let task : mod_vtm.mod_model.mod_task.type_task = mod_vtm.mod_model.mod_round.task_read(round.model); + let id : string = mod_vtm.mod_model.mod_task.id(task); let key : string = ("vtm_" + id); // - let welt : mod_vtm.mod_aufbau.mod_welt.typ_welt = mod_vtm.mod_aufbau.mod_partie.welt_lesen(partie.aufbau); - let welt_ : any = mod_vtm.mod_aufbau.mod_welt.exportieren(welt); - let item : string = JSON.stringify(welt_); + let world : mod_vtm.mod_model.mod_world.type_world = mod_vtm.mod_model.mod_round.world_read(round.model); + let world_ : any = mod_vtm.mod_model.mod_world.export_(world); + let item : string = JSON.stringify(world_); localStorage.setItem(key, item); } ) ; - mod_vtm.mod_aufbau.mod_partie.lauschen + mod_vtm.mod_model.mod_round.lauschen ( - partie.aufbau, - "aenderung_figur", - (angaben) => + round.model, + "aendrung_token", + (data) => { - // console.info("aenderung_figur", angaben); + // console.info("aendrung_token", data); } ) ; - mod_vtm.mod_aufbau.mod_partie.lauschen + mod_vtm.mod_model.mod_round.lauschen ( - partie.aufbau, - "aenderung_modus", - (angaben) => + round.model, + "aendrung_mode", + (data) => { - // console.info("aenderung_modus", angaben); + // console.info("aendrung_mode", data); } ) ; @@ -151,13 +151,13 @@ module mod_vtm /** * @author kcf */ - lib_brauch.umsetzen> + lib_trait.attend> ( - brauch_manifestation, - "speicher_partie", + trait_manifestation, + "store_round", { - "darstellen": (manifestation) => darstellen(manifestation.angaben), - "binden": (manifestation) => binden(manifestation.angaben), + "view": (manifestation) => view(manifestation.data), + "bind": (manifestation) => bind(manifestation.data), } ) ; diff --git a/quelldatein/manifestation/svg/_svg.ts b/quelldatein/manifestation/svg/_svg.ts index 33cddb7..34ec697 100644 --- a/quelldatein/manifestation/svg/_svg.ts +++ b/quelldatein/manifestation/svg/_svg.ts @@ -28,13 +28,13 @@ module mod_vtm /** * @author kcf */ - export const float_praezission : int = 4; + export const float_precision : int = 4; /** * @author kcf */ - export const form_pfeil : string = "M +4 0 L 0 +1 L 0 -1 Z"; + export const shape_arrow : string = "M +4 0 L 0 +1 L 0 -1 Z"; /** @@ -49,7 +49,7 @@ module mod_vtm return ( "rotate" + "(" - + (staerke * 360).toFixed(float_praezission) + + (staerke * 360).toFixed(float_precision) + ")" ); } @@ -68,9 +68,9 @@ module mod_vtm return ( "translate" + "(" - + x.toFixed(float_praezission) + + x.toFixed(float_precision) + ", " - + y.toFixed(float_praezission) + + y.toFixed(float_precision) + ")" ); } @@ -88,7 +88,7 @@ module mod_vtm return ( "scale" + "(" - + staerke.toFixed(float_praezission) + + staerke.toFixed(float_precision) + ")" ); } @@ -97,13 +97,13 @@ module mod_vtm /** * @author kcf */ - export function pfad + export function path ( - vertices : Array, - schliessen : boolean = true, - attribute : {[schlussel : string] : string} = {}, + vertices : Array, + close : boolean = true, + attributes : {[schlussel : string] : string} = {}, ) - : lib_xml.typ_knoten + : lib_xml.type_node { let d : string = ""; vertices.forEach @@ -111,23 +111,23 @@ module mod_vtm (vertex, index) => { let c : string = ((index <= 0) ? "M" : "L"); - let x : string = vertex.x.toFixed(float_praezission); - let y : string = vertex.y.toFixed(float_praezission); + let x : string = vertex.x.toFixed(float_precision); + let y : string = vertex.y.toFixed(float_precision); d += [c, x, y].join(" "); } ) ; - if (schliessen) + if (close) d += "Z"; - attribute["d"] = d; - return (lib_xml.erstellen_normal("path", attribute)); + attributes["d"] = d; + return (lib_xml.create_normal("path", attributes)); } /** * @author kcf */ - export function wurzel + export function root ( von_x : float, von_y : float, @@ -135,12 +135,12 @@ module mod_vtm bis_y : float, hoehe : int = 500, breite : int = 500, - kinder : Array = [] + children : Array = [] ) - : lib_xml.typ_knoten + : lib_xml.type_node { return ( - lib_xml.erstellen_normal + lib_xml.create_normal ( "svg", { @@ -150,7 +150,7 @@ module mod_vtm "height": hoehe.toFixed(0), "viewBox": [von_x.toFixed(4), von_y.toFixed(4), (bis_x-von_x).toFixed(4), (bis_y-von_y).toFixed(4)].join(" "), }, - kinder, + children, ) ); } diff --git a/quelldatein/manifestation/svg/aktor/_aktor.ts b/quelldatein/manifestation/svg/aktor/_aktor.ts index 7be98b4..704d023 100644 --- a/quelldatein/manifestation/svg/aktor/_aktor.ts +++ b/quelldatein/manifestation/svg/aktor/_aktor.ts @@ -25,15 +25,15 @@ module mod_vtm export module mod_svg { - export module mod_aktor + export module mod_actuator { /** * @author kcf */ - export type signatur_aktor = + export type signature_actuator = { - darstellen : (aktor : mod_vtm.mod_aufbau.mod_aktor.typ_aktor)=>Array; + view : (actuator : mod_vtm.mod_model.mod_actuator.type_actuator)=>Array; } ; @@ -41,16 +41,16 @@ module mod_vtm /** * @author kcf */ - export var brauch_aktor : lib_brauch.typ_brauch = lib_brauch.erstellen(); + export var trait_actuator : lib_trait.type_trait = lib_trait.create(); /** * @author kcf */ - export type typ_aktor = + export type type_actuator = { - aufbau : mod_vtm.mod_aufbau.mod_aktor.typ_aktor; - stelle : mod_vtm.mod_aufbau.mod_stelle.typ_stelle; + model : mod_vtm.mod_model.mod_actuator.type_actuator; + spot : mod_vtm.mod_model.mod_spot.type_spot; } ; @@ -58,16 +58,16 @@ module mod_vtm /** * @author kcf */ - function erstellen + function create ( - aufbau : mod_vtm.mod_aufbau.mod_aktor.typ_aktor, - stelle : mod_vtm.mod_aufbau.mod_stelle.typ_stelle + model : mod_vtm.mod_model.mod_actuator.type_actuator, + spot : mod_vtm.mod_model.mod_spot.type_spot ) - : typ_aktor + : type_actuator { return { - "aufbau": aufbau, - "stelle": stelle + "model": model, + "spot": spot }; } @@ -75,16 +75,16 @@ module mod_vtm /** * @author kcf */ - export function erstellen_manifestation + export function create_manifestation ( - aufbau : mod_vtm.mod_aufbau.mod_aktor.typ_aktor, - stelle : mod_vtm.mod_aufbau.mod_stelle.typ_stelle + model : mod_vtm.mod_model.mod_actuator.type_actuator, + spot : mod_vtm.mod_model.mod_spot.type_spot ) - : typ_manifestation + : type_manifestation { return { - "art": "svg_aktor", - "angaben": erstellen(aufbau, stelle), + "kind": "svg_actuator", + "data": create(model, spot), }; } @@ -92,15 +92,15 @@ module mod_vtm /** * @author kcf */ - function darstellen(aktor_ : typ_aktor) : lib_xml.typ_knoten + function view(actuator_ : type_actuator) : lib_xml.type_node { - let aktor : mod_vtm.mod_aufbau.mod_aktor.typ_aktor = aktor_.aufbau; - let knoten_rahmen = function () : lib_xml.typ_knoten + let actuator : mod_vtm.mod_model.mod_actuator.type_actuator = actuator_.model; + let node_rahmen = function () : lib_xml.type_node { return ( - pfad + path ( - mod_vtm.mod_helfer.sequenz(6).map(i => lib_vektor.polar(((i+0.5)/6) * (2*Math.PI), 0.5)), + mod_vtm.mod_helfer.sequence(6).map(i => lib_vector.polar(((i+0.5)/6) * (2*Math.PI), 0.5)), true, { "class": "rahmen" @@ -109,30 +109,30 @@ module mod_vtm ); } ; - let position : mod_position.typ_position = mod_position.von_stelle(aktor_.stelle); - let knoten_feld : lib_xml.typ_knoten = ( - lib_xml.erstellen_normal + let position : mod_position.type_position = mod_position.von_spot(actuator_.spot); + let node_tile : lib_xml.type_node = ( + lib_xml.create_normal ( "g", { - "class": "feld", - "rel": mod_vtm.mod_aufbau.mod_stelle.hash(aktor_.stelle), + "class": "tile", + "rel": mod_vtm.mod_model.mod_spot.hash(actuator_.spot), "transform": translation(position.x, position.y), }, ( - [knoten_rahmen()] - .concat(lib_brauch.anwenden(brauch_aktor, aktor.art)["darstellen"](aktor)) + [node_rahmen()] + .concat(lib_trait.deploy(trait_actuator, actuator.kind)["view"](actuator)) ) ) ); - return knoten_feld; + return node_tile; } /** * @author kcf */ - function binden(aktor : typ_aktor) : void + function bind(actuator : type_actuator) : void { } @@ -140,13 +140,13 @@ module mod_vtm /** * @author kcf */ - lib_brauch.umsetzen> + lib_trait.attend> ( - brauch_manifestation, - "svg_aktor", + trait_manifestation, + "svg_actuator", { - "darstellen": (manifestation) => darstellen(manifestation.angaben), - "binden": (manifestation) => binden(manifestation.angaben), + "view": (manifestation) => view(manifestation.data), + "bind": (manifestation) => bind(manifestation.data), } ) ; diff --git a/quelldatein/manifestation/svg/aktor/annehmer.ts b/quelldatein/manifestation/svg/aktor/annehmer.ts index 5b59ac3..3b3f09d 100644 --- a/quelldatein/manifestation/svg/aktor/annehmer.ts +++ b/quelldatein/manifestation/svg/aktor/annehmer.ts @@ -25,28 +25,28 @@ module mod_vtm export module mod_svg { - export module mod_aktor + export module mod_actuator { /** * @author kcf */ - lib_brauch.umsetzen + lib_trait.attend ( - brauch_aktor, + trait_actuator, "annehmer", { - "darstellen": (aktor) => + "view": (actuator) => { - let kinder : Array = []; - let knoten_kreis : lib_xml.typ_knoten = ( - lib_xml.erstellen_normal + let children : Array = []; + let node_kreis : lib_xml.type_node = ( + lib_xml.create_normal ( "circle", { - "cx": (0.0).toFixed(float_praezission), - "cy": (0.0).toFixed(float_praezission), - "r": (0.25).toFixed(float_praezission), + "cx": (0.0).toFixed(float_precision), + "cy": (0.0).toFixed(float_precision), + "r": (0.25).toFixed(float_precision), "class": ( [ "kreis", @@ -56,8 +56,8 @@ module mod_vtm } ) ); - kinder.push(knoten_kreis); - return kinder; + children.push(node_kreis); + return children; } , } diff --git a/quelldatein/manifestation/svg/aktor/befoerderer.ts b/quelldatein/manifestation/svg/aktor/befoerderer.ts index 6c0789b..df013a8 100644 --- a/quelldatein/manifestation/svg/aktor/befoerderer.ts +++ b/quelldatein/manifestation/svg/aktor/befoerderer.ts @@ -25,26 +25,26 @@ module mod_vtm export module mod_svg { - export module mod_aktor + export module mod_actuator { /** * @author kcf */ - lib_brauch.umsetzen + lib_trait.attend ( - brauch_aktor, + trait_actuator, "befoerderer", { - "darstellen": ({"angaben": {"richtung": richtung}}) => + "view": ({"data": {"direction": direction}}) => { - let kinder : Array = []; - let knoten_pfeil : lib_xml.typ_knoten = ( - lib_xml.erstellen_normal + let children : Array = []; + let node_pfeil : lib_xml.type_node = ( + lib_xml.create_normal ( "path", { - "d": form_pfeil, + "d": shape_arrow, "class": ( [ "pfeil", @@ -53,7 +53,7 @@ module mod_vtm ), "transform": ( [ - rotation(richtung/6), + rotation(direction/6), translation(-0.2, 0), skalierung(0.12), ].join(" ") @@ -61,8 +61,8 @@ module mod_vtm } ) ); - kinder.push(knoten_pfeil); - return kinder; + children.push(node_pfeil); + return children; } , } diff --git a/quelldatein/manifestation/svg/aktor/erzeuger.ts b/quelldatein/manifestation/svg/aktor/erzeuger.ts index ca01179..5575c07 100644 --- a/quelldatein/manifestation/svg/aktor/erzeuger.ts +++ b/quelldatein/manifestation/svg/aktor/erzeuger.ts @@ -25,26 +25,26 @@ module mod_vtm export module mod_svg { - export module mod_aktor + export module mod_actuator { /** * @author kcf */ - lib_brauch.umsetzen + lib_trait.attend ( - brauch_aktor, + trait_actuator, "erzeuger", { - "darstellen": ({"angaben": {"richtung": richtung}}) => + "view": ({"data": {"direction": direction}}) => { - let kinder : Array = []; - let knoten_pfeil : lib_xml.typ_knoten = ( - lib_xml.erstellen_normal + let children : Array = []; + let node_pfeil : lib_xml.type_node = ( + lib_xml.create_normal ( "path", { - "d": form_pfeil, + "d": shape_arrow, "class": ( [ "pfeil", @@ -53,7 +53,7 @@ module mod_vtm ), "transform": ( [ - rotation(richtung/6), + rotation(direction/6), translation(-0.2, 0), skalierung(0.12), ].join(" ") @@ -61,8 +61,8 @@ module mod_vtm } ) ); - kinder.push(knoten_pfeil); - return kinder; + children.push(node_pfeil); + return children; } , } diff --git a/quelldatein/manifestation/svg/aktor/leser.ts b/quelldatein/manifestation/svg/aktor/leser.ts index 6d0c28d..a614112 100644 --- a/quelldatein/manifestation/svg/aktor/leser.ts +++ b/quelldatein/manifestation/svg/aktor/leser.ts @@ -25,39 +25,39 @@ module mod_vtm export module mod_svg { - export module mod_aktor + export module mod_actuator { /** * @author kcf */ - lib_brauch.umsetzen + lib_trait.attend ( - brauch_aktor, + trait_actuator, "leser", { - "darstellen": ({"angaben": {"richtung": richtung, "symbol_links": symbol_links, "symbol_rechts": symbol_rechts}}) => + "view": ({"data": {"direction": direction, "symbol_links": symbol_links, "symbol_rechts": symbol_rechts}}) => { - let kinder : Array = []; - type typ_eintrag = + let children : Array = []; + type type_eintrag = { - summand : mod_vtm.mod_aufbau.mod_richtung.typ_richtung; - symbol : lib_fehlermonade.typ_fehlermonade; + summand : mod_vtm.mod_model.mod_direction.type_direction; + symbol : lib_errormonade.type_errormonade; } ; - let ausgaenge : Array = + let ausgaenge : Array = [ { "summand": 0, - "symbol": lib_fehlermonade.erstellen_nichts(), + "symbol": lib_errormonade.create_nothing(), }, { "summand": +2, - "symbol": lib_fehlermonade.erstellen_schlicht(symbol_links), + "symbol": lib_errormonade.create_just(symbol_links), }, { "summand": -2, - "symbol": lib_fehlermonade.erstellen_schlicht(symbol_rechts), + "symbol": lib_errormonade.create_just(symbol_rechts), }, ] ; @@ -65,26 +65,26 @@ module mod_vtm ( eintrag => { - let winkelstaerke : float = (mod_vtm.mod_aufbau.mod_richtung.addieren(richtung, eintrag.summand) / 6); - let knoten_pfeil : lib_xml.typ_knoten = ( - lib_xml.erstellen_normal + let anglestaerke : float = (mod_vtm.mod_model.mod_direction.add(direction, eintrag.summand) / 6); + let node_pfeil : lib_xml.type_node = ( + lib_xml.create_normal ( "path", { - "d": form_pfeil, + "d": shape_arrow, "class": ( [ "pfeil", ( - lib_fehlermonade.voll(eintrag.symbol) - ? "symbol_" + lib_fehlermonade.lesen(eintrag.symbol).toFixed(0) + lib_errormonade.filled(eintrag.symbol) + ? "symbol_" + lib_errormonade.read(eintrag.symbol).toFixed(0) : "neutral" ), ].join(" ") ), "transform": ( [ - rotation(winkelstaerke), + rotation(anglestaerke), translation(+0.1, 0), skalierung(0.075), ].join(" ") @@ -92,11 +92,11 @@ module mod_vtm } ) ); - kinder.push(knoten_pfeil); + children.push(node_pfeil); } ) ; - return kinder; + return children; } , } diff --git a/quelldatein/manifestation/svg/aktor/schreiber.ts b/quelldatein/manifestation/svg/aktor/schreiber.ts index fb21a16..5c283a9 100644 --- a/quelldatein/manifestation/svg/aktor/schreiber.ts +++ b/quelldatein/manifestation/svg/aktor/schreiber.ts @@ -25,26 +25,26 @@ module mod_vtm export module mod_svg { - export module mod_aktor + export module mod_actuator { /** * @author kcf */ - lib_brauch.umsetzen + lib_trait.attend ( - brauch_aktor, + trait_actuator, "schreiber", { - "darstellen": ({"angaben": {"richtung": richtung, "symbol": symbol}}) => + "view": ({"data": {"direction": direction, "symbol": symbol}}) => { - let kinder : Array = []; - let knoten_pfeil : lib_xml.typ_knoten = ( - lib_xml.erstellen_normal + let children : Array = []; + let node_pfeil : lib_xml.type_node = ( + lib_xml.create_normal ( "path", { - "d": form_pfeil, + "d": shape_arrow, "class": ( [ "pfeil", @@ -53,7 +53,7 @@ module mod_vtm ), "transform": ( [ - rotation(richtung/6), + rotation(direction/6), translation(-0.2, 0), skalierung(0.12), ].join(" ") @@ -61,8 +61,8 @@ module mod_vtm } ) ); - kinder.push(knoten_pfeil); - return kinder; + children.push(node_pfeil); + return children; } , } diff --git a/quelldatein/manifestation/svg/aktor/verwerfer.ts b/quelldatein/manifestation/svg/aktor/verwerfer.ts index 1ce8cd3..d74edd7 100644 --- a/quelldatein/manifestation/svg/aktor/verwerfer.ts +++ b/quelldatein/manifestation/svg/aktor/verwerfer.ts @@ -25,28 +25,28 @@ module mod_vtm export module mod_svg { - export module mod_aktor + export module mod_actuator { /** * @author kcf */ - lib_brauch.umsetzen + lib_trait.attend ( - brauch_aktor, + trait_actuator, "verwerfer", { - "darstellen": (aktor) => + "view": (actuator) => { - let kinder : Array = []; - let knoten_kreis : lib_xml.typ_knoten = ( - lib_xml.erstellen_normal + let children : Array = []; + let node_kreis : lib_xml.type_node = ( + lib_xml.create_normal ( "circle", { - "cx": (0.0).toFixed(float_praezission), - "cy": (0.0).toFixed(float_praezission), - "r": (0.25).toFixed(float_praezission), + "cx": (0.0).toFixed(float_precision), + "cy": (0.0).toFixed(float_precision), + "r": (0.25).toFixed(float_precision), "class": ( [ "kreis", @@ -56,8 +56,8 @@ module mod_vtm } ) ); - kinder.push(knoten_kreis); - return kinder; + children.push(node_kreis); + return children; } , } diff --git a/quelldatein/manifestation/svg/figur.ts b/quelldatein/manifestation/svg/figur.ts index 47aa987..c5bc8b6 100644 --- a/quelldatein/manifestation/svg/figur.ts +++ b/quelldatein/manifestation/svg/figur.ts @@ -25,15 +25,15 @@ module mod_vtm export module mod_svg { - export module mod_figur + export module mod_token { /** * @author kcf */ - export type typ_figur = + export type type_token = { - aufbau : mod_vtm.mod_aufbau.mod_figur.typ_figur; + model : mod_vtm.mod_model.mod_token.type_token; } ; @@ -41,14 +41,14 @@ module mod_vtm /** * @author kcf */ - function erstellen + function create ( - aufbau : mod_vtm.mod_aufbau.mod_figur.typ_figur + model : mod_vtm.mod_model.mod_token.type_token ) - : typ_figur + : type_token { return { - "aufbau": aufbau, + "model": model, }; } @@ -56,15 +56,15 @@ module mod_vtm /** * @author kcf */ - export function erstellen_manifestation + export function create_manifestation ( - aufbau : mod_vtm.mod_aufbau.mod_figur.typ_figur + model : mod_vtm.mod_model.mod_token.type_token ) - : typ_manifestation + : type_manifestation { return { - "art": "svg_figur", - "angaben": erstellen(aufbau), + "kind": "svg_token", + "data": create(model), }; } @@ -72,54 +72,54 @@ module mod_vtm /** * @author kcf */ - function darstellen + function view ( - figur_ : typ_figur + token_ : type_token ) - : lib_xml.typ_knoten + : lib_xml.type_node { - let figur : mod_vtm.mod_aufbau.mod_figur.typ_figur = figur_.aufbau; - let kinder_figur : Array = []; + let token : mod_vtm.mod_model.mod_token.type_token = token_.model; + let children_token : Array = []; // Stein { - let knoten_stein : lib_xml.typ_knoten = ( - lib_xml.erstellen_normal + let node_stein : lib_xml.type_node = ( + lib_xml.create_normal ( "circle", { - "cx": (0.0).toFixed(float_praezission), - "cy": (0.0).toFixed(float_praezission), - "r": (0.125).toFixed(float_praezission), + "cx": (0.0).toFixed(float_precision), + "cy": (0.0).toFixed(float_precision), + "r": (0.125).toFixed(float_precision), "class": "stein", } ) ); - kinder_figur.push(knoten_stein); + children_token.push(node_stein); } // Band { - let band : Array = mod_vtm.mod_aufbau.mod_figur.band_lesen(figur); - let kinder_band : Array = []; - band.forEach + let tape : Array = mod_vtm.mod_model.mod_token.tape_read(token); + let children_tape : Array = []; + tape.forEach ( (symbol, index) => { let r : float = 0.06125; let x : float = (+0.1+(2*r*1.25)*index); let y : float = (-0.1); - let knoten_eintrag : lib_xml.typ_knoten = ( - lib_xml.erstellen_normal + let node_eintrag : lib_xml.type_node = ( + lib_xml.create_normal ( "circle", { - "cx": x.toFixed(float_praezission), - "cy": y.toFixed(float_praezission), - "r": r.toFixed(float_praezission), + "cx": x.toFixed(float_precision), + "cy": y.toFixed(float_precision), + "r": r.toFixed(float_precision), /* - "x": (x-r).toFixed(float_praezission), - "y": (y-r).toFixed(float_praezission), - "width": (2*r).toFixed(float_praezission), - "height": (2*r).toFixed(float_praezission), + "x": (x-r).toFixed(float_precision), + "y": (y-r).toFixed(float_precision), + "width": (2*r).toFixed(float_precision), + "height": (2*r).toFixed(float_precision), */ "class": ( [ @@ -130,42 +130,42 @@ module mod_vtm } ) ); - kinder_band.push(knoten_eintrag); + children_tape.push(node_eintrag); } ) ; - let knoten_band = ( - lib_xml.erstellen_normal + let node_tape = ( + lib_xml.create_normal ( "g", { - "class": "band", + "class": "tape", }, - kinder_band + children_tape ) ); - kinder_figur.push(knoten_band); + children_token.push(node_tape); } - let position : mod_position.typ_position = mod_position.von_stelle(mod_vtm.mod_aufbau.mod_figur.stelle_lesen(figur)); - let knoten_figur = ( - lib_xml.erstellen_normal + let position : mod_position.type_position = mod_position.von_spot(mod_vtm.mod_model.mod_token.spot_read(token)); + let node_token = ( + lib_xml.create_normal ( "g", { - "class": "figur", + "class": "token", "transform": translation(position.x, position.y), }, - kinder_figur + children_token ) ); - return knoten_figur; + return node_token; } /** * @author kcf */ - function binden(figur : typ_figur) : void + function bind(token : type_token) : void { } @@ -173,13 +173,13 @@ module mod_vtm /** * @author kcf */ - lib_brauch.umsetzen> + lib_trait.attend> ( - brauch_manifestation, - "svg_figur", + trait_manifestation, + "svg_token", { - "darstellen": (manifestation) => darstellen(manifestation.angaben), - "binden": (manifestation) => binden(manifestation.angaben), + "view": (manifestation) => view(manifestation.data), + "bind": (manifestation) => bind(manifestation.data), } ) ; diff --git a/quelldatein/manifestation/svg/partie.ts b/quelldatein/manifestation/svg/partie.ts index 239e40c..18076ce 100644 --- a/quelldatein/manifestation/svg/partie.ts +++ b/quelldatein/manifestation/svg/partie.ts @@ -25,15 +25,15 @@ module mod_vtm export module mod_svg { - export module mod_partie + export module mod_round { /** * @author kcf */ - export type typ_partie = + export type type_round = { - aufbau : mod_vtm.mod_aufbau.mod_partie.typ_partie; + model : mod_vtm.mod_model.mod_round.type_round; } ; @@ -41,10 +41,10 @@ module mod_vtm /** * @author kcf */ - function erstellen(aufbau : mod_vtm.mod_aufbau.mod_partie.typ_partie) : typ_partie + function create(model : mod_vtm.mod_model.mod_round.type_round) : type_round { return { - "aufbau": aufbau + "model": model }; } @@ -52,11 +52,11 @@ module mod_vtm /** * @author kcf */ - export function erstellen_manifestation(aufbau : mod_vtm.mod_aufbau.mod_partie.typ_partie) : typ_manifestation + export function create_manifestation(model : mod_vtm.mod_model.mod_round.type_round) : type_manifestation { return { - "art": "svg_partie", - "angaben": erstellen(aufbau) + "kind": "svg_round", + "data": create(model) }; } @@ -64,83 +64,83 @@ module mod_vtm /** * @author kcf */ - function darstellen(partie : typ_partie) : lib_xml.typ_knoten + function view(round : type_round) : lib_xml.type_node { - let kinder_partie : Array = []; + let children_round : Array = []; // Welt { - let kinder_welt : Array = []; + let children_world : Array = []; // Felder { - let kinder_felder : Array = []; - mod_vtm.mod_aufbau.mod_welt.felder_lesen(mod_vtm.mod_aufbau.mod_partie.welt_lesen(partie.aufbau)).forEach + let children_tiles : Array = []; + mod_vtm.mod_model.mod_world.tiles_read(mod_vtm.mod_model.mod_round.world_read(round.model)).forEach ( - ({"stelle": stelle, "aktor": aktor}) => + ({"spot": spot, "actuator": actuator}) => { - let manifestation_feld : typ_manifestation = mod_aktor.erstellen_manifestation(aktor, stelle); - let knoten_feld : lib_xml.typ_knoten = mod_manifestation.darstellen(manifestation_feld); - kinder_felder.push(knoten_feld); + let manifestation_tile : type_manifestation = mod_actuator.create_manifestation(actuator, spot); + let node_tile : lib_xml.type_node = mod_manifestation.view(manifestation_tile); + children_tiles.push(node_tile); } ) ; - let knoten_felder : lib_xml.typ_knoten = ( - lib_xml.erstellen_normal + let node_tiles : lib_xml.type_node = ( + lib_xml.create_normal ( "g", { - "class": "felder", + "class": "tiles", }, - kinder_felder + children_tiles ) ); - kinder_welt.push(knoten_felder); + children_world.push(node_tiles); } - let knoten_welt : lib_xml.typ_knoten = ( - lib_xml.erstellen_normal + let node_world : lib_xml.type_node = ( + lib_xml.create_normal ( "g", { - "class": "welt", + "class": "world", }, - kinder_welt + children_world ) ); - kinder_partie.push(knoten_welt); + children_round.push(node_world); } // Figur { - let figur_ : lib_fehlermonade.typ_fehlermonade = mod_vtm.mod_aufbau.mod_partie.figur_lesen(partie.aufbau); - if (lib_fehlermonade.voll(figur_)) + let token_ : lib_errormonade.type_errormonade = mod_vtm.mod_model.mod_round.token_read(round.model); + if (lib_errormonade.filled(token_)) { - let figur : mod_vtm.mod_aufbau.mod_figur.typ_figur = lib_fehlermonade.lesen(figur_); - let manifestation_figur : typ_manifestation = mod_figur.erstellen_manifestation(figur); - let knoten_figur : lib_xml.typ_knoten = mod_manifestation.darstellen(manifestation_figur); - kinder_partie.push(knoten_figur); + let token : mod_vtm.mod_model.mod_token.type_token = lib_errormonade.read(token_); + let manifestation_token : type_manifestation = mod_token.create_manifestation(token); + let node_token : lib_xml.type_node = mod_manifestation.view(manifestation_token); + children_round.push(node_token); } else { - // nichts tun + // nothing tun } } - let knoten_partie : lib_xml.typ_knoten = ( - lib_xml.erstellen_normal + let node_round : lib_xml.type_node = ( + lib_xml.create_normal ( "g", { - "class": "partie", + "class": "round", }, - kinder_partie + children_round ) ); - return knoten_partie; + return node_round; } /** * @author kcf */ - function binden(partie : typ_partie) : void + function bind(round : type_round) : void { } @@ -148,13 +148,13 @@ module mod_vtm /** * @author kcf */ - lib_brauch.umsetzen> + lib_trait.attend> ( - brauch_manifestation, - "svg_partie", + trait_manifestation, + "svg_round", { - "darstellen": (manifestation) => darstellen(manifestation.angaben), - "binden": (manifestation) => binden(manifestation.angaben), + "view": (manifestation) => view(manifestation.data), + "bind": (manifestation) => bind(manifestation.data), } ) ; diff --git a/quelldatein/manifestation/web/partie.ts b/quelldatein/manifestation/web/partie.ts index 76d1308..7a3f6b7 100644 --- a/quelldatein/manifestation/web/partie.ts +++ b/quelldatein/manifestation/web/partie.ts @@ -25,13 +25,13 @@ module mod_vtm export module mod_web { - export module mod_partie + export module mod_round { /** * @author kcf */ - function text_nachbearbeiten(text : string) : string + function text_nachedit(text : string) : string { let regexp : RegExp = (new RegExp("\\$\{s(\\d*)\}", "g")); return text.replace(regexp, "  "); @@ -41,11 +41,11 @@ module mod_vtm /** * @author kcf */ - export type typ_partie = + export type type_round = { - aufbau : mod_aufbau.mod_partie.typ_partie; - bereich : Element; - intervall : lib_fehlermonade.typ_fehlermonade; + model : mod_model.mod_round.type_round; + area : Element; + intervall : lib_errormonade.type_errormonade; } ; @@ -53,17 +53,17 @@ module mod_vtm /** * @author kcf */ - function erstellen + function create ( - aufbau : mod_aufbau.mod_partie.typ_partie, - bereich : Element + model : mod_model.mod_round.type_round, + area : Element ) - : typ_partie + : type_round { return { - "aufbau": aufbau, - "bereich": bereich, - "intervall": (lib_fehlermonade.erstellen_nichts()), + "model": model, + "area": area, + "intervall": (lib_errormonade.create_nothing()), }; } @@ -71,16 +71,16 @@ module mod_vtm /** * @author kcf */ - export function erstellen_erweitert + export function create_erweitert ( - aufbau : mod_aufbau.mod_partie.typ_partie, - bereich : Element + model : mod_model.mod_round.type_round, + area : Element ) - : typ_manifestation + : type_manifestation { return { - "art": "web_partie", - "angaben": erstellen(aufbau, bereich) + "kind": "web_round", + "data": create(model, area) }; } @@ -88,14 +88,14 @@ module mod_vtm /** * @author kcf */ - function erneuern_aufgabe(partie : typ_partie) : void + function update_task(round : type_round) : void { - document.querySelector("#aufgabe_text").innerHTML = ( - text_nachbearbeiten + document.querySelector("#task_text").innerHTML = ( + text_nachedit ( - mod_vtm.mod_aufbau.mod_aufgabe.text + mod_vtm.mod_model.mod_task.text ( - mod_vtm.mod_aufbau.mod_partie.aufgabe_lesen(partie.aufbau) + mod_vtm.mod_model.mod_round.task_read(round.model) ) ) ); @@ -105,103 +105,103 @@ module mod_vtm /** * @author kcf */ - function erneuern_welt(partie : typ_partie) : void + function update_world(round : type_round) : void { - let knoten_svg : lib_xml.typ_knoten = mod_svg.wurzel + let node_svg : lib_xml.type_node = mod_svg.root ( -4, -4, +4, +4, 800, 800, - [mod_manifestation.darstellen(mod_svg.mod_partie.erstellen_manifestation(partie.aufbau))] + [mod_manifestation.view(mod_svg.mod_round.create_manifestation(round.model))] ) ; - partie.bereich.innerHTML = lib_xml.darstellen(knoten_svg); + round.area.innerHTML = lib_xml.view(node_svg); } /** * @author kcf */ - function erneuern_figur(partie : typ_partie) : void + function update_token(round : type_round) : void { - let knoten_svg : lib_xml.typ_knoten = mod_svg.wurzel + let node_svg : lib_xml.type_node = mod_svg.root ( -4, -4, +4, +4, 800, 800, - [mod_manifestation.darstellen(mod_svg.mod_partie.erstellen_manifestation(partie.aufbau))] + [mod_manifestation.view(mod_svg.mod_round.create_manifestation(round.model))] ) ; - partie.bereich.innerHTML = lib_xml.darstellen(knoten_svg); + round.area.innerHTML = lib_xml.view(node_svg); } /** * @author kcf */ - function erneuern_modus(partie : typ_partie) : void + function update_mode(round : type_round) : void { let status : string; - switch (mod_vtm.mod_aufbau.mod_partie.modus_lesen(partie.aufbau)) + switch (mod_vtm.mod_model.mod_round.mode_read(round.model)) { - case mod_vtm.mod_aufbau.mod_modus.initial: + case mod_vtm.mod_model.mod_mode.initial: { - status = "Maschine aufbauen"; + status = lib_translate.get("model.modes.initial"); break; } - case mod_vtm.mod_aufbau.mod_modus.ungewiss: + case mod_vtm.mod_model.mod_mode.uncertain: { - status = "wird geprüft …"; + status = lib_translate.get("model.modes.uncertain"); break; } - case mod_vtm.mod_aufbau.mod_modus.fehlerhaft: + case mod_vtm.mod_model.mod_mode.wrong: { - status = "fehlerhaft :/"; + status = lib_translate.get("model.modes.wrong"); break; } - case mod_vtm.mod_aufbau.mod_modus.korrekt: + case mod_vtm.mod_model.mod_mode.correct: { - status = "anscheinend korrekt :)"; + status = lib_translate.get("model.modes.correct"); break; } default: { - let meldung : string = "unbehandelter Modus"; - throw (new Error(meldung)); + let message : string = "unbehandelter Modus"; + throw (new Error(message)); break; } } - document.querySelector("#aufgabe_status").textContent = status; + document.querySelector("#task_status").textContent = status; } /** * @author kcf */ - function erneuern_knoepfe(partie : typ_partie) : void + function update_buttons(round : type_round) : void { - let modus : mod_vtm.mod_aufbau.mod_modus.typ_modus = mod_vtm.mod_aufbau.mod_partie.modus_lesen(partie.aufbau); + let mode : mod_vtm.mod_model.mod_mode.type_mode = mod_vtm.mod_model.mod_round.mode_read(round.model); let klasse : string; - switch (modus) + switch (mode) { - case mod_vtm.mod_aufbau.mod_modus.initial: + case mod_vtm.mod_model.mod_mode.initial: { klasse = "initial"; break; } - case mod_vtm.mod_aufbau.mod_modus.ungewiss: + case mod_vtm.mod_model.mod_mode.uncertain: { klasse = ( - lib_fehlermonade.voll(partie.intervall) - ? "ungewiss_laufend" - : "ungewiss_stehend" + lib_errormonade.filled(round.intervall) + ? "uncertain_running" + : "uncertain_standing" ); break; } - case mod_vtm.mod_aufbau.mod_modus.fehlerhaft: - case mod_vtm.mod_aufbau.mod_modus.korrekt: + case mod_vtm.mod_model.mod_mode.wrong: + case mod_vtm.mod_model.mod_mode.correct: { - klasse = "fertig"; + klasse = "done"; break; } default: @@ -210,164 +210,164 @@ module mod_vtm break; } } - document.querySelector("#knoepfe").setAttribute("class", klasse); + document.querySelector("#buttons").setAttribute("class", klasse); } /** * @author kcf */ - function darstellen(partie : typ_partie) : void + function view(round : type_round) : void { - erneuern_aufgabe(partie); - erneuern_welt(partie); - erneuern_figur(partie); - erneuern_modus(partie); - erneuern_knoepfe(partie); + update_task(round); + update_world(round); + update_token(round); + update_mode(round); + update_buttons(round); } /** * @author kcf */ - function anhalten(partie : typ_partie) : void + function stop(round : type_round) : void { - if (lib_fehlermonade.voll(partie.intervall)) + if (lib_errormonade.filled(round.intervall)) { - clearInterval(lib_fehlermonade.lesen(partie.intervall)); - partie.intervall = (lib_fehlermonade.erstellen_nichts()); + clearInterval(lib_errormonade.read(round.intervall)); + round.intervall = (lib_errormonade.create_nothing()); } else { - let meldung : string = "kein Intervall gesetzt"; - console.warn(meldung); + let message : string = "kein Intervall gesetzt"; + console.warn(message); } - erneuern_knoepfe(partie); + update_buttons(round); } /** * @author kcf */ - function fortfahren(partie : typ_partie) : void + function resume(round : type_round) : void { - mod_vtm.mod_aufbau.mod_partie.fortfahren(partie.aufbau); - let modus : mod_vtm.mod_aufbau.mod_modus.typ_modus = mod_vtm.mod_aufbau.mod_partie.modus_lesen(partie.aufbau); - if (modus <= 1) + mod_vtm.mod_model.mod_round.resume(round.model); + let mode : mod_vtm.mod_model.mod_mode.type_mode = mod_vtm.mod_model.mod_round.mode_read(round.model); + if (mode <= 1) { - // nichts tun + // nothing tun } else { - anhalten(partie); + stop(round); } - erneuern_knoepfe(partie); + update_buttons(round); } /** * @author kcf */ - function testen(partie : typ_partie) : void + function testen(round : type_round) : void { - let handle : any = setInterval(() => fortfahren(partie), 500); - partie.intervall = (lib_fehlermonade.erstellen_schlicht(handle)); + let handle : any = setInterval(() => resume(round), 500); + round.intervall = (lib_errormonade.create_just(handle)); } /** * @author kcf */ - function bearbeiten(partie : typ_partie) : void + function edit(round : type_round) : void { - anhalten(partie); - mod_vtm.mod_aufbau.mod_partie.zuruecksetzen(partie.aufbau); + stop(round); + mod_vtm.mod_model.mod_round.reset(round.model); } /** * @author kcf */ - function leeren(partie : typ_partie) : void + function clear(round : type_round) : void { - mod_vtm.mod_aufbau.mod_partie.welt_leeren(partie.aufbau); - mod_vtm.mod_aufbau.mod_partie.zuruecksetzen(partie.aufbau); + mod_vtm.mod_model.mod_round.world_clear(round.model); + mod_vtm.mod_model.mod_round.reset(round.model); } /** * @author kcf */ - function binden(partie : typ_partie) : void + function bind(round : type_round) : void { - let stelle_ermitteln = (target : EventTarget) => + let spot_ermitteln = (target : EventTarget) => { - let stelle : lib_fehlermonade.typ_fehlermonade; - let dom_feld : Element = target["closest"](".feld"); - if (dom_feld == null) + let spot : lib_errormonade.type_errormonade; + let dom_tile : Element = target["closest"](".tile"); + if (dom_tile == null) { - stelle = (lib_fehlermonade.erstellen_nichts()); + spot = (lib_errormonade.create_nothing()); } else { - let rel : string = dom_feld.getAttribute("rel") - stelle = (lib_fehlermonade.erstellen_schlicht(mod_vtm.mod_aufbau.mod_stelle.von_hash(rel))); + let rel : string = dom_tile.getAttribute("rel") + spot = (lib_errormonade.create_just(mod_vtm.mod_model.mod_spot.von_hash(rel))); } - return stelle; + return spot; } ; - mod_vtm.mod_aufbau.mod_partie.lauschen + mod_vtm.mod_model.mod_round.lauschen ( - partie.aufbau, - "aenderung_aufgabe", - (angaben) => + round.model, + "aendrung_task", + (data) => { - erneuern_aufgabe(partie); + update_task(round); } ) ; - mod_vtm.mod_aufbau.mod_partie.lauschen + mod_vtm.mod_model.mod_round.lauschen ( - partie.aufbau, - "aenderung_welt", - (angaben) => + round.model, + "aendrung_world", + (data) => { - erneuern_welt(partie); + update_world(round); } ) ; - mod_vtm.mod_aufbau.mod_partie.lauschen + mod_vtm.mod_model.mod_round.lauschen ( - partie.aufbau, - "aenderung_figur", - (angaben) => + round.model, + "aendrung_token", + (data) => { - erneuern_figur(partie); + update_token(round); } ) ; - mod_vtm.mod_aufbau.mod_partie.lauschen + mod_vtm.mod_model.mod_round.lauschen ( - partie.aufbau, - "aenderung_modus", - (angaben) => + round.model, + "aendrung_mode", + (data) => { - erneuern_modus(partie); - erneuern_knoepfe(partie); + update_mode(round); + update_buttons(round); } ) ; // Links-Klick - partie.bereich.addEventListener + round.area.addEventListener ( "click", event => { event.preventDefault(); - let stelle_ : lib_fehlermonade.typ_fehlermonade = stelle_ermitteln(event.target); - if (lib_fehlermonade.voll(stelle_)) + let spot_ : lib_errormonade.type_errormonade = spot_ermitteln(event.target); + if (lib_errormonade.filled(spot_)) { - mod_vtm.mod_aufbau.mod_partie.welt_feld_wechseln(partie.aufbau, lib_fehlermonade.lesen(stelle_), false); + mod_vtm.mod_model.mod_round.world_tile_wechseln(round.model, lib_errormonade.read(spot_), false); } else { @@ -377,16 +377,16 @@ module mod_vtm ) ; // Rechts-Klick - partie.bereich.addEventListener + round.area.addEventListener ( "contextmenu", event => { event.preventDefault(); - let stelle_ : lib_fehlermonade.typ_fehlermonade = stelle_ermitteln(event.target); - if (lib_fehlermonade.voll(stelle_)) + let spot_ : lib_errormonade.type_errormonade = spot_ermitteln(event.target); + if (lib_errormonade.filled(spot_)) { - mod_vtm.mod_aufbau.mod_partie.welt_feld_wechseln(partie.aufbau, lib_fehlermonade.lesen(stelle_), true); + mod_vtm.mod_model.mod_round.world_tile_wechseln(round.model, lib_errormonade.read(spot_), true); } else { @@ -396,17 +396,17 @@ module mod_vtm ) ; // Mausrad - partie.bereich.addEventListener + round.area.addEventListener ( "wheel", event => { event.preventDefault(); - let stelle_ : lib_fehlermonade.typ_fehlermonade = stelle_ermitteln(event.target); - if (lib_fehlermonade.voll(stelle_)) + let spot_ : lib_errormonade.type_errormonade = spot_ermitteln(event.target); + if (lib_errormonade.filled(spot_)) { let inkrement : int = ((event["deltaY"] < 0) ? -1 : +1); - mod_vtm.mod_aufbau.mod_partie.welt_feld_drehen(partie.aufbau, lib_fehlermonade.lesen(stelle_), inkrement); + mod_vtm.mod_model.mod_round.world_tile_rotate(round.model, lib_errormonade.read(spot_), inkrement); } else { @@ -416,53 +416,53 @@ module mod_vtm ) ; // Schritt - document.querySelector("#knopf_schritt").addEventListener + document.querySelector("#button_step").addEventListener ( "click", event => { - anhalten(partie); - fortfahren(partie); + stop(round); + resume(round); } ) ; // Testen - document.querySelector("#knopf_testen").addEventListener + document.querySelector("#button_test").addEventListener ( "click", event => { - testen(partie); + testen(round); } ) ; - // Anhalten - document.querySelector("#knopf_anhalten").addEventListener + // stop + document.querySelector("#button_stop").addEventListener ( "click", event => { - anhalten(partie); + stop(round); } ) ; - // Bearbeiten - document.querySelector("#knopf_bearbeiten").addEventListener + // edit + document.querySelector("#button_edit").addEventListener ( "click", event => { - bearbeiten(partie); + edit(round); } ) ; // Leeren - document.querySelector("#knopf_leeren").addEventListener + document.querySelector("#button_clear").addEventListener ( "click", event => { - leeren(partie); + clear(round); } ) ; @@ -472,13 +472,13 @@ module mod_vtm /** * @author kcf */ - lib_brauch.umsetzen> + lib_trait.attend> ( - brauch_manifestation, - "web_partie", + trait_manifestation, + "web_round", { - "darstellen": (manifestation) => darstellen(manifestation.angaben), - "binden": (manifestation) => binden(manifestation.angaben), + "view": (manifestation) => view(manifestation.data), + "bind": (manifestation) => bind(manifestation.data), } ) ; diff --git a/quelldatein/manifestation/web/vtm.html b/quelldatein/manifestation/web/vtm.html index 9322603..7dcfba5 100644 --- a/quelldatein/manifestation/web/vtm.html +++ b/quelldatein/manifestation/web/vtm.html @@ -4,99 +4,99 @@ - + -
!translate:allgemein.titel
- - +
!translate:common.title
+ + -
-