save

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 <vidofnir@folksprak.org>
 						 */
-						export type typ_aktor = lib_aufruf.typ_komplex<any>;
+						export type type_actuator = lib_call.type_complex<any>;
 						
 						
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export type signatur_aktor =
+						export type signature_actuator =
 							{
-								beispiel : ()=>typ_aktor;
+								example : ()=>type_actuator;
-								drehen : (aktor : typ_aktor, inkrement : int)=>void;
+								rotate : (actuator : type_actuator, inkrement : int)=>void;
-								verwenden : (aktor : typ_aktor, figur : mod_figur.typ_figur)=>void;
+								use : (actuator : type_actuator, token : mod_token.type_token)=>void;
-								exportieren : (aktor : typ_aktor)=>any;
+								export : (actuator : type_actuator)=>any;
-								importieren : (roh : any)=>typ_aktor;
+								import : (raw : any)=>type_actuator;
 							}
 						;
 						
@@ -48,16 +48,16 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export var brauch_aktor : lib_brauch.typ_brauch<signatur_aktor> = lib_brauch.erstellen<signatur_aktor>();
+						export var trait_actuator : lib_trait.type_trait<signature_actuator> = lib_trait.create<signature_actuator>();
 						
 						
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
 						/*
-						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 <vidofnir@folksprak.org>
 						 */
-						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 <vidofnir@folksprak.org>
 						 */
-						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 <vidofnir@folksprak.org>
 						 */
-						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 <vidofnir@folksprak.org>
 						 */
-						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 <vidofnir@folksprak.org>
 						 */
-						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);
 							}
 						
 					}

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 <vidofnir@folksprak.org>
 								 */
-								let art : string = "annehmer";
+								let kind : string = "annehmer";
 								
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								export type typ_annehmer =
+								export type type_annehmer =
 									{
 									}
 								;
@@ -46,10 +46,10 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								function erstellen
+								function create
 									(
 									)
-									: typ_annehmer
+									: type_annehmer
 									{
 										return {
 										};
@@ -59,33 +59,33 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								function beispiel
+								function example
 									(
 									)
-									: typ_annehmer
+									: type_annehmer
 									{
-										return erstellen();
+										return create();
 									}
 								
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								function drehen
+								function rotate
 									(
-										annehmer : typ_annehmer,
+										annehmer : type_annehmer,
 										inkrement ?: int
 									)
 									: void
@@ -96,23 +96,23 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								function verwenden
+								function use
 									(
-										annehmer : typ_annehmer,
+										annehmer : type_annehmer,
-										figur : mod_figur.typ_figur
+										token : mod_token.type_token
 									)
 									: void
 									{
-										mod_figur.annehmen(figur);
+										mod_token.accept(token);
 									}
 								
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								function exportieren
+								function export_
 									(
-										annehmer : typ_annehmer
+										annehmer : type_annehmer
 									)
 									: any
 									{
@@ -124,14 +124,14 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								function importieren
+								function import_
 									(
-										roh : any
+										raw : any
 									)
-									: typ_annehmer
+									: type_annehmer
 									{
 										return (
-											erstellen
+											create
 												(
 												)
 										);
@@ -141,16 +141,16 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								lib_brauch.umsetzen<signatur_aktor>
+								lib_trait.attend<signature_actuator>
 									(
-										brauch_aktor,
+										trait_actuator,
-										art,
+										kind,
 										{
-											"beispiel": () => lib_aufruf.einpacken(art, beispiel()),
+											"example": () => lib_call.wrap(kind, example()),
-											"drehen": (aktor, inkrement) => drehen(lib_aufruf.auspacken(aktor), inkrement),
+											"rotate": (actuator, inkrement) => rotate(lib_call.unwrap(actuator), inkrement),
-											"verwenden": (aktor, figur) => verwenden(lib_aufruf.auspacken(aktor), figur),
+											"use": (actuator, token) => use(lib_call.unwrap(actuator), token),
-											"exportieren": (aktor) => ({"art": art, "angaben": exportieren(aktor.angaben)}),
+											"export": (actuator) => ({"kind": kind, "data": export_(actuator.data)}),
-											"importieren": (roh) => lib_aufruf.einpacken(art, importieren(roh["angaben"])),
+											"import": (raw) => lib_call.wrap(kind, import_(raw["data"])),
 										}
 									)
 								;

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 <vidofnir@folksprak.org>
 								 */
-								let art : string = "befoerderer";
+								let kind : string = "befoerderer";
 								
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								function beispiel
+								function example
 									(
 									)
-									: typ_befoerderer
+									: type_befoerderer
 									{
-										return erstellen(0);
+										return create(0);
 									}
 								
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								function verwenden
+								function use
 									(
-										befoerderer : typ_befoerderer,
+										befoerderer : type_befoerderer,
-										figur : mod_figur.typ_figur
+										token : mod_token.type_token
 									)
 									: void
 									{
-										mod_figur.bewegen(figur, befoerderer.richtung);
+										mod_token.move(token, befoerderer.direction);
 									}
 								
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								lib_brauch.umsetzen<signatur_aktor>
+								lib_trait.attend<signature_actuator>
 									(
-										brauch_aktor,
+										trait_actuator,
-										art,
+										kind,
 										{
-											"beispiel": () => lib_aufruf.einpacken(art, beispiel()),
+											"example": () => lib_call.wrap(kind, example()),
-											"drehen": (aktor, inkrement) => drehen(lib_aufruf.auspacken(aktor), inkrement),
+											"rotate": (actuator, inkrement) => rotate(lib_call.unwrap(actuator), inkrement),
-											"verwenden": (aktor, figur) => verwenden(lib_aufruf.auspacken(aktor), figur),
+											"use": (actuator, token) => use(lib_call.unwrap(actuator), token),
-											"exportieren": (aktor) => ({"art": art, "angaben": exportieren(aktor.angaben)}),
+											"export": (actuator) => ({"kind": kind, "data": export_(actuator.data)}),
-											"importieren": (roh) => lib_aufruf.einpacken(art, importieren(roh["angaben"])),
+											"import": (raw) => lib_call.wrap(kind, import_(raw["data"])),
 										}
 									)
 								;

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 <vidofnir@folksprak.org>
 								 */
-								let art : string = "erzeuger";
+								let kind : string = "erzeuger";
 								
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								function beispiel
+								function example
 									(
 									)
-									: typ_erzeuger
+									: type_erzeuger
 									{
-										return erstellen(0);
+										return create(0);
 									}
 								
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								function verwenden
+								function use
 									(
-										erzeuger : typ_erzeuger,
+										erzeuger : type_erzeuger,
-										figur : mod_figur.typ_figur
+										token : mod_token.type_token
 									)
 									: void
 									{
-										mod_figur.bewegen(figur, erzeuger.richtung);
+										mod_token.move(token, erzeuger.direction);
 									}
 								
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								lib_brauch.umsetzen<signatur_aktor>
+								lib_trait.attend<signature_actuator>
 									(
-										brauch_aktor,
+										trait_actuator,
-										art,
+										kind,
 										{
-											"beispiel": () => lib_aufruf.einpacken(art, beispiel()),
+											"example": () => lib_call.wrap(kind, example()),
-											"drehen": (aktor, inkrement) => drehen(lib_aufruf.auspacken(aktor), inkrement),
+											"rotate": (actuator, inkrement) => rotate(lib_call.unwrap(actuator), inkrement),
-											"verwenden": (aktor, figur) => verwenden(lib_aufruf.auspacken(aktor), figur),
+											"use": (actuator, token) => use(lib_call.unwrap(actuator), token),
-											"exportieren": (aktor) => ({"art": art, "angaben": exportieren(aktor.angaben)}),
+											"export": (actuator) => ({"kind": kind, "data": export_(actuator.data)}),
-											"importieren": (roh) => lib_aufruf.einpacken(art, importieren(roh["angaben"])),
+											"import": (raw) => lib_call.wrap(kind, import_(raw["data"])),
 										}
 									)
 								;

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 <vidofnir@folksprak.org>
 								 */
-								let art : string = "leser";
+								let kind : string = "leser";
 								
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								export type typ_leser =
+								export type type_leser =
 									{
-										"richtung": mod_richtung.typ_richtung,
+										"direction": mod_direction.type_direction,
-										"symbol_links": mod_symbol.typ_symbol,
+										"symbol_links": mod_symbol.type_symbol,
-										"symbol_rechts": mod_symbol.typ_symbol,
+										"symbol_rechts": mod_symbol.type_symbol,
 									}
 								;
 								
@@ -49,16 +49,16 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								 function erstellen
+								 function create
 									(
-										richtung : mod_richtung.typ_richtung,
+										direction : mod_direction.type_direction,
-										symbol_links : mod_symbol.typ_symbol,
+										symbol_links : mod_symbol.type_symbol,
-										symbol_rechts : mod_symbol.typ_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 <vidofnir@folksprak.org>
 								 */
-								export function erstellen_aktor
+								export function create_actuator
 									(
-										richtung : mod_richtung.typ_richtung,
+										direction : mod_direction.type_direction,
-										symbol_links : mod_symbol.typ_symbol,
+										symbol_links : mod_symbol.type_symbol,
-										symbol_rechts : mod_symbol.typ_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 <vidofnir@folksprak.org>
 								 */
-								function beispiel
+								function example
 									(
 									)
-									: typ_leser
+									: type_leser
 									{
-										return erstellen(0, 0, 1);
+										return create(0, 0, 1);
 									}
 								
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								function verwenden
+								function use
 									(
-										leser : typ_leser,
+										leser : type_leser,
-										figur : mod_figur.typ_figur
+										token : mod_token.type_token
 									)
 									: void
 									{
-										let symbol_ : lib_fehlermonade.typ_fehlermonade<mod_symbol.typ_symbol> = mod_figur.lesen(figur);
+										let symbol_ : lib_errormonade.type_errormonade<mod_symbol.type_symbol> = mod_token.read(token);
-										let summand : mod_richtung.typ_richtung;
+										let summand : mod_direction.type_direction;
-										if (lib_fehlermonade.voll(symbol_))
+										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);
+										let direction : mod_direction.type_direction = mod_direction.add(leser.direction, summand);
-										mod_figur.bewegen(figur, richtung);
+										mod_token.move(token, direction);
 									}
 								
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								function exportieren
+								function export_
 									(
-										leser : typ_leser
+										leser : type_leser
 									)
 									: any
 									{
 										return {
-											"richtung": mod_richtung.exportieren(leser.richtung),
+											"direction": mod_direction.export_(leser.direction),
-											"symbol_links": mod_symbol.exportieren(leser.symbol_links),
+											"symbol_links": mod_symbol.export_(leser.symbol_links),
-											"symbol_rechts": mod_symbol.exportieren(leser.symbol_rechts),
+											"symbol_rechts": mod_symbol.export_(leser.symbol_rechts),
 										};
 									}
 								
@@ -204,18 +204,18 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								function importieren
+								function import_
 									(
-										roh : any
+										raw : any
 									)
-									: typ_leser
+									: type_leser
 									{
 										return (
-											erstellen
+											create
 												(
-													mod_richtung.importieren(roh["richtung"]),
+													mod_direction.import_(raw["direction"]),
-													mod_symbol.importieren(roh["symbol_links"]),
+													mod_symbol.import_(raw["symbol_links"]),
-													mod_symbol.importieren(roh["symbol_rechts"])
+													mod_symbol.import_(raw["symbol_rechts"])
 												)
 										);
 									}
@@ -224,16 +224,16 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								lib_brauch.umsetzen<signatur_aktor>
+								lib_trait.attend<signature_actuator>
 									(
-										brauch_aktor,
+										trait_actuator,
-										art,
+										kind,
 										{
-											"beispiel": () => lib_aufruf.einpacken(art, beispiel()),
+											"example": () => lib_call.wrap(kind, example()),
-											"drehen": (aktor, inkrement) => drehen(lib_aufruf.auspacken(aktor), inkrement),
+											"rotate": (actuator, inkrement) => rotate(lib_call.unwrap(actuator), inkrement),
-											"verwenden": (aktor, figur) => verwenden(lib_aufruf.auspacken(aktor), figur),
+											"use": (actuator, token) => use(lib_call.unwrap(actuator), token),
-											"exportieren": (aktor) => ({"art": art, "angaben": exportieren(aktor.angaben)}),
+											"export": (actuator) => ({"kind": kind, "data": export_(actuator.data)}),
-											"importieren": (roh) => lib_aufruf.einpacken(art, importieren(roh["angaben"])),
+											"import": (raw) => lib_call.wrap(kind, import_(raw["data"])),
 										}
 									)
 								;

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 <vidofnir@folksprak.org>
 								 */
-								let art : string = "schreiber";
+								let kind : string = "schreiber";
 				
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								export type typ_schreiber =
+								export type type_schreiber =
 									{
-										richtung : mod_richtung.typ_richtung;
+										direction : mod_direction.type_direction;
-										symbol : mod_symbol.typ_symbol;
+										symbol : mod_symbol.type_symbol;
 									}
 								;
 								
@@ -48,15 +48,15 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								function erstellen
+								function create
 									(
-										richtung : mod_richtung.typ_richtung,
+										direction : mod_direction.type_direction,
-										symbol : mod_symbol.typ_symbol
+										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 <vidofnir@folksprak.org>
 								 */
-								export function erstellen_aktor
+								export function create_actuator
 									(
-										richtung : mod_richtung.typ_richtung,
+										direction : mod_direction.type_direction,
-										symbol : mod_symbol.typ_symbol
+										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 <vidofnir@folksprak.org>
 								 */
-								function beispiel
+								function example
 									(
 									)
-									: typ_schreiber
+									: type_schreiber
 									{
-										return erstellen(0, 0);
+										return create(0, 0);
 									}
 								
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								function verwenden
+								function use
 									(
-										schreiber : typ_schreiber,
+										schreiber : type_schreiber,
-										figur : mod_figur.typ_figur
+										token : mod_token.type_token
 									)
 									: void
 									{
-										mod_figur.schreiben(figur, schreiber.symbol);
+										mod_token.write(token, schreiber.symbol);
-										mod_figur.bewegen(figur, schreiber.richtung);
+										mod_token.move(token, schreiber.direction);
 									}
 								
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								function exportieren
+								function export_
 									(
-										schreiber : typ_schreiber
+										schreiber : type_schreiber
 									)
 									: any
 									{
 										return {
-											"richtung": mod_richtung.exportieren(schreiber.richtung),
+											"direction": mod_direction.export_(schreiber.direction),
-											"symbol": mod_symbol.exportieren(schreiber.symbol),
+											"symbol": mod_symbol.export_(schreiber.symbol),
 										};
 									}
 								
@@ -162,17 +162,17 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								function importieren
+								function import_
 									(
-										roh : any
+										raw : any
 									)
-									: typ_schreiber
+									: type_schreiber
 									{
 										return (
-											erstellen
+											create
 												(
-													mod_richtung.importieren(roh["richtung"]),
+													mod_direction.import_(raw["direction"]),
-													mod_symbol.importieren(roh["symbol"])
+													mod_symbol.import_(raw["symbol"])
 												)
 										);
 									}
@@ -181,16 +181,16 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								lib_brauch.umsetzen<signatur_aktor>
+								lib_trait.attend<signature_actuator>
 									(
-										brauch_aktor,
+										trait_actuator,
-										art,
+										kind,
 										{
-											"beispiel": () => lib_aufruf.einpacken(art, beispiel()),
+											"example": () => lib_call.wrap(kind, example()),
-											"drehen": (aktor, inkrement) => drehen(lib_aufruf.auspacken(aktor), inkrement),
+											"rotate": (actuator, inkrement) => rotate(lib_call.unwrap(actuator), inkrement),
-											"verwenden": (aktor, figur) => verwenden(lib_aufruf.auspacken(aktor), figur),
+											"use": (actuator, token) => use(lib_call.unwrap(actuator), token),
-											"exportieren": (aktor) => ({"art": art, "angaben": exportieren(aktor.angaben)}),
+											"export": (actuator) => ({"kind": kind, "data": export_(actuator.data)}),
-											"importieren": (roh) => lib_aufruf.einpacken(art, importieren(roh["angaben"])),
+											"import": (raw) => lib_call.wrap(kind, import_(raw["data"])),
 										}
 									)
 								;

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 <vidofnir@folksprak.org>
 								 */
-								let art : string = "verwerfer";
+								let kind : string = "verwerfer";
 								
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								export type typ_verwerfer =
+								export type type_verwerfer =
 									{
 									}
 								;
@@ -46,10 +46,10 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								function erstellen
+								function create
 									(
 									)
-									: typ_verwerfer
+									: type_verwerfer
 									{
 										return {
 										};
@@ -59,33 +59,33 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								function beispiel
+								function example
 									(
 									)
-									: typ_verwerfer
+									: type_verwerfer
 									{
-										return erstellen();
+										return create();
 									}
 								
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								function drehen
+								function rotate
 									(
-										verwerfer : typ_verwerfer,
+										verwerfer : type_verwerfer,
 										inkrement ?: int
 									)
 									: void
@@ -96,23 +96,23 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								function verwenden
+								function use
 									(
-										verwerfer : typ_verwerfer,
+										verwerfer : type_verwerfer,
-										figur : mod_figur.typ_figur
+										token : mod_token.type_token
 									)
 									: void
 									{
-										mod_figur.verwerfen(figur);
+										mod_token.reject(token);
 									}
 								
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								function exportieren
+								function export_
 									(
-										verwerfer : typ_verwerfer
+										verwerfer : type_verwerfer
 									)
 									: any
 									{
@@ -124,14 +124,14 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								function importieren
+								function import_
 									(
-										roh : any
+										raw : any
 									)
-									: typ_verwerfer
+									: type_verwerfer
 									{
 										return (
-											erstellen
+											create
 												(
 												)
 										);
@@ -141,16 +141,16 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								lib_brauch.umsetzen<signatur_aktor>
+								lib_trait.attend<signature_actuator>
 									(
-										brauch_aktor,
+										trait_actuator,
-										art,
+										kind,
 										{
-											"beispiel": () => lib_aufruf.einpacken(art, beispiel()),
+											"example": () => lib_call.wrap(kind, example()),
-											"drehen": (aktor, inkrement) => drehen(lib_aufruf.auspacken(aktor), inkrement),
+											"rotate": (actuator, inkrement) => rotate(lib_call.unwrap(actuator), inkrement),
-											"verwenden": (aktor, figur) => verwenden(lib_aufruf.auspacken(aktor), figur),
+											"use": (actuator, token) => use(lib_call.unwrap(actuator), token),
-											"exportieren": (aktor) => ({"art": art, "angaben": exportieren(aktor.angaben)}),
+											"export": (actuator) => ({"kind": kind, "data": export_(actuator.data)}),
-											"importieren": (roh) => lib_aufruf.einpacken(art, importieren(roh["angaben"])),
+											"import": (raw) => lib_call.wrap(kind, import_(raw["data"])),
 										}
 									)
 								;

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 <vidofnir@folksprak.org>
 						 */
-						export type typ_akzeptoraufgabe =
+						export type type_acceptortask =
 							{
 								id : string;
 								titel : string;
 								text : string;
-								tests : Array<mod_akzeptortest.typ_akzeptortest>;
+								tests : Array<mod_acceptortest.type_acceptortest>;
 							}
 						;
 						
@@ -41,14 +41,14 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export function erstellen
+						export function create
 							(
 								id : string,
 								titel : string,
 								text : string,
-								tests : Array<mod_akzeptortest.typ_akzeptortest>
+								tests : Array<mod_acceptortest.type_acceptortest>
 							)
-							: 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<mod_akzeptortest.typ_akzeptortest>
+							: Array<mod_acceptortest.type_acceptortest>
 							{
-								return akzeptoraufgabe.tests;
+								return acceptortask.tests;
 							}
 						
 					}

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 <vidofnir@folksprak.org>
 						 */
-						export type typ_akzeptortest =
+						export type type_acceptortest =
 							{
-								eingabe : Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>;
+								input : Array<mod_vtm.mod_model.mod_symbol.type_symbol>;
-								annehmen : boolean;
+								accept : boolean;
 							}
 						;
 						
@@ -39,16 +39,16 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export function erstellen
+						export function create
 							(
-								eingabe : Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>,
+								input : Array<mod_vtm.mod_model.mod_symbol.type_symbol>,
-								annehmen : boolean
+								accept : boolean
 							)
-							: typ_akzeptortest
+							: type_acceptortest
 							{
 								return {
-									"eingabe": eingabe,
+									"input": input,
-									"annehmen": annehmen,
+									"accept": accept,
 								};
 							}
 						
@@ -56,13 +56,13 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export function eingabe
+						export function input
 							(
-								akzeptortest : typ_akzeptortest
+								acceptortest : type_acceptortest
 							)
-							: Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>
+							: Array<mod_vtm.mod_model.mod_symbol.type_symbol>
 							{
-								return akzeptortest.eingabe;
+								return acceptortest.input;
 							}
 						
 						
@@ -71,13 +71,13 @@ module mod_vtm
 						 */
 						export function pruefen
 							(
-								akzeptortest : typ_akzeptortest,
+								acceptortest : type_acceptortest,
-								angenommen : boolean,
+								accepted : boolean,
-								ausgabe : Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>
+								ausgabe : Array<mod_vtm.mod_model.mod_symbol.type_symbol>
 							)
 							: boolean
 							{
-								return (akzeptortest.annehmen === angenommen);
+								return (acceptortest.accept === accepted);
 							}
 						
 					}

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 <vidofnir@folksprak.org>
 						 */
-						export type typ_aufgabe = lib_aufruf.typ_komplex<Object>;
+						export type type_task = lib_call.type_complex<Object>;
 						
 						
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						var _liste : Array<typ_aufgabe> = [];
+						var _liste : Array<type_task> = [];
 						
 						
 						/**
@@ -42,17 +42,17 @@ module mod_vtm
 						 */
 						export function id
 							(
-								aufgabe : typ_aufgabe
+								task : type_task
 							)
 							: string
 							{
 								return (
-									lib_aufruf.fallunterscheidung<string>
+									lib_call.distinguish<string>
 										(
-											aufgabe,
+											task,
 											{
-												"akzeptoraufgabe": (angaben) => mod_akzeptoraufgabe.id(angaben),
+												"acceptortask": (data) => mod_acceptortask.id(data),
-												"transduktoraufgabe": (angaben) => mod_transduktoraufgabe.id(angaben),
+												"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<string>
+									lib_call.distinguish<string>
 										(
-											aufgabe,
+											task,
 											{
-												"akzeptoraufgabe": (angaben) => mod_akzeptoraufgabe.titel(angaben),
+												"acceptortask": (data) => mod_acceptortask.titel(data),
-												"transduktoraufgabe": (angaben) => mod_transduktoraufgabe.titel(angaben),
+												"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<string>
+									lib_call.distinguish<string>
 										(
-											aufgabe,
+											task,
 											{
-												"akzeptoraufgabe": (angaben) => mod_akzeptoraufgabe.text(angaben),
+												"acceptortask": (data) => mod_acceptortask.text(data),
-												"transduktoraufgabe": (angaben) => mod_transduktoraufgabe.text(angaben),
+												"transductortask": (data) => mod_transductortask.text(data),
 											}
 										)
 								);
@@ -108,22 +108,22 @@ module mod_vtm
 						 */
 						export function tests
 							(
-								aufgabe : typ_aufgabe
+								task : type_task
 							)
-							: Array<mod_test.typ_test>
+							: Array<mod_test.type_test>
 							{
 								return (
-									lib_aufruf.fallunterscheidung<Array<mod_test.typ_test>>
+									lib_call.distinguish<Array<mod_test.type_test>>
 										(
-											aufgabe,
+											task,
 											{
-												"akzeptoraufgabe": (angaben) => (
+												"acceptortask": (data) => (
-													mod_akzeptoraufgabe.tests(angaben)
+													mod_acceptortask.tests(data)
-													.map(angaben_ => ({"art": "akzeptortest", "angaben": angaben_}))
+													.map(data_ => ({"kind": "acceptortest", "data": data_}))
 												),
-												"transduktoraufgabe": (angaben) => (
+												"transductortask": (data) => (
-													mod_transduktoraufgabe.tests(angaben)
+													mod_transductortask.tests(data)
-													.map(angaben_ => ({"art": "transduktortest", "angaben": angaben_}))
+													.map(data_ => ({"kind": "transductortest", "data": data_}))
 												),
 											}
 										)
@@ -134,27 +134,27 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						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",
+													"kind": "acceptortask",
-													"angaben": (
+													"data": (
-														mod_akzeptoraufgabe.erstellen
+														mod_acceptortask.create
 															(
-																aufgabe_roh["id"],
+																task_raw["id"],
-																aufgabe_roh["parameter"]["titel"],
+																task_raw["parameter"]["titel"],
-																aufgabe_roh["parameter"]["text"],
+																task_raw["parameter"]["text"],
-																aufgabe_roh["parameter"]["tests"].map
+																task_raw["parameter"]["tests"].map
 																	(
-																		test_roh => (
+																		test_raw => (
-																			mod_akzeptortest.erstellen
+																			mod_acceptortest.create
 																				(
-																					test_roh["eingabe"],
+																					test_raw["input"],
-																					test_roh["annehmen"]
+																					test_raw["accept"]
 																				)
 																		)
 																	)
@@ -163,23 +163,23 @@ module mod_vtm
 												};
 												break;
 											}
-										case "transduktor":
+										case "transductor":
 											{
 												return {
-													"art": "transduktoraufgabe",
+													"kind": "transductortask",
-													"angaben": (
+													"data": (
-														mod_transduktoraufgabe.erstellen
+														mod_transductortask.create
 															(
-																aufgabe_roh["id"],
+																task_raw["id"],
-																aufgabe_roh["parameter"]["titel"],
+																task_raw["parameter"]["titel"],
-																aufgabe_roh["parameter"]["text"],
+																task_raw["parameter"]["text"],
-																aufgabe_roh["parameter"]["tests"].map
+																task_raw["parameter"]["tests"].map
 																	(
-																		test_roh => (
+																		test_raw => (
-																			mod_transduktortest.erstellen
+																			mod_transductortest.create
 																				(
-																					test_roh["eingabe"],
+																					test_raw["input"],
-																					test_roh["ausgabe"]
+																					test_raw["output"]
 																				)
 																		)
 																	)
@@ -190,8 +190,8 @@ module mod_vtm
 											}
 										default:
 											{
-												let meldung : string = "unbehandelte Art";
+												let message : string = "unbehandelte Art '" + task_raw["kind"] + "'";
-												throw (new Error(meldung));
+												throw (new Error(message));
 												break;
 											}
 									}
@@ -201,16 +201,16 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export function registrieren(aufgabe : typ_aufgabe) : void
+						export function registrieren(task : type_task) : void
 							{
-								_liste.push(aufgabe);
+								_liste.push(task);
 							}
 						
 						
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export function holen(index : int) : typ_aufgabe
+						export function get(index : int) : type_task
 							{
 								return _liste[index];
 							}

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 <vidofnir@folksprak.org>
 						 */
-						export type typ_test = lib_aufruf.typ_komplex<Object>;
+						export type type_test = lib_call.type_complex<Object>;
 						
 						
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export function eingabe
+						export function input
 							(
-								test : typ_test
+								test : type_test
 							)
-							: Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>
+							: Array<mod_vtm.mod_model.mod_symbol.type_symbol>
 							{
 								return (
-									lib_aufruf.fallunterscheidung<Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>>
+									lib_call.distinguish<Array<mod_vtm.mod_model.mod_symbol.type_symbol>>
 										(
 											test,
 											{
-												"akzeptortest": (angaben) => mod_akzeptortest.eingabe(angaben),
+												"acceptortest": (data) => mod_acceptortest.input(data),
-												"transduktortest": (angaben) => mod_transduktortest.eingabe(angaben),
+												"transductortest": (data) => mod_transductortest.input(data),
 											}
 										)
 								);
@@ -58,19 +58,19 @@ module mod_vtm
 						 */
 						export function pruefen
 							(
-								test : typ_test,
+								test : type_test,
-								angenommen : boolean,
+								accepted : boolean,
-								ausgabe : Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>
+								ausgabe : Array<mod_vtm.mod_model.mod_symbol.type_symbol>
 							)
 							: boolean
 							{
 								return (
-									lib_aufruf.fallunterscheidung<boolean>
+									lib_call.distinguish<boolean>
 										(
 											test,
 											{
-												"akzeptortest": (angaben) => mod_akzeptortest.pruefen(angaben, angenommen, ausgabe),
+												"acceptortest": (data) => mod_acceptortest.pruefen(data, accepted, ausgabe),
-												"transduktortest": (angaben) => mod_transduktortest.pruefen(angaben, angenommen, ausgabe),
+												"transductortest": (data) => mod_transductortest.pruefen(data, accepted, ausgabe),
 											}
 										)
 								);
@@ -80,37 +80,37 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						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",
+													"kind": "acceptortest",
-													"angaben": (
+													"data": (
-														mod_akzeptortest.erstellen
+														mod_acceptortest.create
 															(
-																test_roh["angaben"]["eingabe"],
+																test_raw["data"]["input"],
-																test_roh["angaben"]["annehmen"]
+																test_raw["data"]["accept"]
 															)
 													),
 												};
 												break;
 											}
-										case "transduktortest":
+										case "transductortest":
 											{
 												return {
-													"art": "transduktortest",
+													"kind": "transductortest",
-													"angaben": (
+													"data": (
-														mod_transduktortest.erstellen
+														mod_transductortest.create
 															(
-																test_roh["angaben"]["eingabe"],
+																test_raw["data"]["input"],
-																test_roh["angaben"]["ausgabe"]
+																test_raw["data"]["output"]
 															)
 													),
 												};

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 <vidofnir@folksprak.org>
 						 */
-						export type typ_transduktoraufgabe =
+						export type type_transductortask =
 							{
 								id : string;
 								titel : string;
 								text : string;
-								tests : Array<mod_transduktortest.typ_transduktortest>;
+								tests : Array<mod_transductortest.type_transductortest>;
 							}
 						;
 						
@@ -41,14 +41,14 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export function erstellen
+						export function create
 							(
 								id : string,
 								titel : string,
 								text : string,
-								tests : Array<mod_transduktortest.typ_transduktortest>
+								tests : Array<mod_transductortest.type_transductortest>
 							)
-							: 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<mod_transduktortest.typ_transduktortest>
+							: Array<mod_transductortest.type_transductortest>
 							{
-								return transduktoraufgabe.tests;
+								return transductortask.tests;
 							}
 						
 					}

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 <vidofnir@folksprak.org>
 						 */
-						export type typ_transduktortest =
+						export type type_transductortest =
 							{
-								eingabe : Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>;
+								input : Array<mod_vtm.mod_model.mod_symbol.type_symbol>;
-								ausgabe : Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>;
+								output : Array<mod_vtm.mod_model.mod_symbol.type_symbol>;
 							}
 						;
 						
@@ -39,16 +39,16 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export function erstellen
+						export function create
 							(
-								eingabe : Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>,
+								input : Array<mod_vtm.mod_model.mod_symbol.type_symbol>,
-								ausgabe : Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>
+								output : Array<mod_vtm.mod_model.mod_symbol.type_symbol>
 							)
-							: typ_transduktortest
+							: type_transductortest
 							{
 								return {
-									"eingabe": eingabe,
+									"input": input,
-									"ausgabe": ausgabe,
+									"output": output,
 								};
 							}
 						
@@ -56,13 +56,13 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export function eingabe
+						export function input
 							(
-								transduktortest : typ_transduktortest
+								transductortest : type_transductortest
 							)
-							: Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>
+							: Array<mod_vtm.mod_model.mod_symbol.type_symbol>
 							{
-								return transduktortest.eingabe;
+								return transductortest.input;
 							}
 						
 						
@@ -71,29 +71,29 @@ module mod_vtm
 						 */
 						export function pruefen
 							(
-								transduktortest : typ_transduktortest,
+								transductortest : type_transductortest,
-								angenommen : boolean,
+								accepted : boolean,
-								ausgabe : Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>
+								output : Array<mod_vtm.mod_model.mod_symbol.type_symbol>
 							)
 							: 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;

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 <vidofnir@folksprak.org>
 						 */
-						export type typ_figur =
+						export type type_token =
 							{
-								zustand : mod_zustand.typ_zustand;
+								state : mod_state.type_state;
-								band : Array<mod_symbol.typ_symbol>;
+								tape : Array<mod_symbol.type_symbol>;
-								stelle : mod_stelle.typ_stelle;
+								spot : mod_spot.type_spot;
 							}
 						;
 						
@@ -40,17 +40,17 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export function erstellen
+						export function create
 							(
-								band : Array<mod_symbol.typ_symbol> = [],
+								tape : Array<mod_symbol.type_symbol> = [],
-								stelle : mod_stelle.typ_stelle = mod_stelle.null_()
+								spot : mod_spot.type_spot = mod_spot.null_()
 							)
-							: typ_figur
+							: type_token
 							{
 								return {
-									"zustand": mod_zustand.laufend,
+									"state": mod_state.running,
-									"band": band,
+									"tape": tape,
-									"stelle": stelle,
+									"spot": spot,
 								};
 							}
 						
@@ -58,87 +58,87 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						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 <vidofnir@folksprak.org>
 						 */
-						export function band_lesen
+						export function tape_read
 							(
-								figur : typ_figur
+								token : type_token
 							)
-							: Array<mod_symbol.typ_symbol>
+							: Array<mod_symbol.type_symbol>
 							{
-								return figur.band;
+								return token.tape;
 							}
 						
 						
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						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 <vidofnir@folksprak.org>
 						 */
-						export function bewegen
+						export function move
 							(
-								figur : typ_figur,
+								token : type_token,
-								richtung : mod_richtung.typ_richtung
+								direction : mod_direction.type_direction
 							)
 							: void
 							{
-								let summand : mod_stelle.typ_stelle = mod_stelle.von_richtung(richtung);
+								let summand : mod_spot.type_spot = mod_spot.von_direction(direction);
-								figur.stelle = mod_stelle.addieren(figur.stelle, summand);
+								token.spot = mod_spot.add(token.spot, summand);
 							}
 						
 						
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export function schreiben
+						export function write
 							(
-								figur : typ_figur,
+								token : type_token,
-								symbol : mod_symbol.typ_symbol
+								symbol : mod_symbol.type_symbol
 							)
 							: void
 							{
-								figur.band.push(symbol);
+								token.tape.push(symbol);
 							}
 						
 						
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export function lesen
+						export function read
 							(
-								figur : typ_figur
+								token : type_token
 							)
-							: lib_fehlermonade.typ_fehlermonade<mod_symbol.typ_symbol>
+							: lib_errormonade.type_errormonade<mod_symbol.type_symbol>
 							{
-								if (figur.band.length <= 0)
+								if (token.tape.length <= 0)
 									{
-										return (lib_fehlermonade.erstellen_nichts<mod_symbol.typ_symbol>());
+										return (lib_errormonade.create_nothing<mod_symbol.type_symbol>());
 									}
 								else
 									{
-										return (lib_fehlermonade.erstellen_schlicht<mod_symbol.typ_symbol>(figur.band[0]));
+										return (lib_errormonade.create_just<mod_symbol.type_symbol>(token.tape[0]));
 									}
 							}
 						
@@ -146,20 +146,20 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						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";
+										let message : string = "Band ist leer";
-										throw (new Error(meldung));
+										throw (new Error(message));
 									}
 								else
 									{
-										figur.band.shift();
+										token.tape.shift();
 									}
 							}
 						
@@ -167,26 +167,26 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						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 <vidofnir@folksprak.org>
 						 */
-						export function verwerfen
+						export function reject
 							(
-								figur : typ_figur
+								token : type_token
 							)
 							: void
 							{
-								figur.zustand = mod_zustand.abgelehnt;
+								token.state = mod_state.rejected;
 							}
 						
 					}

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 <vidofnir@folksprak.org>
 						 */
-						export type typ_modus = int;
+						export type type_mode = int;
 						
 						
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
 						export const initial = 0;
-						export const ungewiss = 1;
+						export const uncertain = 1;
-						export const fehlerhaft = 2;
+						export const wrong = 2;
-						export const korrekt = 3;
+						export const correct = 3;
 						
 					}
 				

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 <vidofnir@folksprak.org>
 						 */
-						export type typ_partie =
+						export type type_round =
 							{
-								welt : mod_welt.typ_welt;
+								world : mod_world.type_world;
-								figur : lib_fehlermonade.typ_fehlermonade<mod_figur.typ_figur>;
+								token : lib_errormonade.type_errormonade<mod_token.type_token>;
-								aufgabe : mod_aufgabe.typ_aufgabe;
+								task : mod_task.type_task;
-								testindex : lib_fehlermonade.typ_fehlermonade<int>;
+								testindex : lib_errormonade.type_errormonade<int>;
-								modus : mod_modus.typ_modus;
+								mode : mod_mode.type_mode;
-								lauscher : {[ereignis : string] : Array<(angaben ?: any)=>void>};
+								listeners : {[event : string] : Array<(data ?: any)=>void>};
 							}
 						;
 						
@@ -43,29 +43,33 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export function erstellen
+						export function create
 							(
-								aufgabe : mod_aufgabe.typ_aufgabe
+								task : mod_task.type_task
 							)
-							: typ_partie
+							: type_round
 							{
-								let partie : typ_partie = {
+								let round : type_round =
-									"welt": undefined,
+									{
-									"figur": undefined,
+										"world": undefined,
-									"aufgabe": aufgabe,
+										"token": undefined,
-									"testindex": undefined,
+										"task": task,
-									"modus": undefined,
+										"testindex": undefined,
-									"lauscher": undefined,
+										"mode": undefined,
-								};
+										"listeners": undefined,
-								partie.lauscher = {
+									}
-									"aenderung_aufgabe": [],
+								;
-									"aenderung_welt": [],
+								round.listeners =
-									"aenderung_figur": [],
+									{
-									"aenderung_modus": [],
+										"aendrung_task": [],
-								};
+										"aendrung_world": [],
-								welt_leeren(partie, false);
+										"aendrung_token": [],
-								zuruecksetzen(partie, false);
+										"aendrung_mode": [],
-								return partie;
+									}
+								;
+								world_clear(round, false);
+								reset(round, false);
+								return round;
 							}
 						
 						
@@ -74,20 +78,20 @@ module mod_vtm
 						 */
 						export function lauschen
 							(
-								partie : typ_partie,
+								round : type_round,
-								ereignis : string,
+								event : string,
-								prozedur : (angaben ?: any)=>void
+								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";
+										let message : string = "kein Ereignis mit diesem Name";
-										throw (new Error(meldung));
+										throw (new Error(message));
 									}
 							}
 						
@@ -95,28 +99,28 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						function benachrichtigen
+						function notify
 							(
-								partie : typ_partie,
+								round : type_round,
-								ereignis : string,
+								event : string,
-								angaben : any = {}
+								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";
+										let message : string = "kein Ereignis mit diesem Name";
-										throw (new Error(meldung));
+										throw (new Error(message));
 									}
 							}
 						
@@ -124,24 +128,24 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export function zuruecksetzen
+						export function reset
 							(
-								partie : typ_partie,
+								round : type_round,
-								bescheid_geben : boolean = true
+								inform : boolean = true
 							)
 							: void
 							{
-								partie.figur = (lib_fehlermonade.erstellen_nichts<mod_figur.typ_figur>());
+								round.token = (lib_errormonade.create_nothing<mod_token.type_token>());
-								partie.testindex = (lib_fehlermonade.erstellen_nichts<int>());
+								round.testindex = (lib_errormonade.create_nothing<int>());
-								partie.modus = mod_modus.initial;
+								round.mode = mod_mode.initial;
-								if (bescheid_geben)
+								if (inform)
 									{
-										benachrichtigen(partie, "aenderung_figur", {});
+										notify(round, "aendrung_token", {});
-										benachrichtigen(partie, "aenderung_modus", {});
+										notify(round, "aendrung_mode", {});
 									}
 								else
 									{
-										// nichts tun
+										// nothing tun
 									}
 							}
 						
@@ -149,64 +153,64 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						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 <vidofnir@folksprak.org>
 						 */
-						export function aufgabe_setzen
+						export function task_set
 							(
-								partie : typ_partie,
+								round : type_round,
-								aufgabe : mod_aufgabe.typ_aufgabe
+								task : mod_task.type_task
 							) : void
 							{
-								partie.aufgabe = aufgabe;
+								round.task = task;
-								// partie.welt_leeren();
+								// round.world_clear();
-								benachrichtigen(partie, "aenderung_aufgabe", {});
+								notify(round, "aendrung_task", {});
-								zuruecksetzen(partie);
+								reset(round);
 							}
 						
 						
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						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 <vidofnir@folksprak.org>
 						 */
-						export function welt_setzen
+						export function world_set
 							(
-								partie : typ_partie,
+								round : type_round,
-								welt : mod_welt.typ_welt,
+								world : mod_world.type_world,
-								bescheid_geben : boolean = true
+								inform : boolean = true
 							)
 							: void
 							{
-								partie.welt = welt;
+								round.world = world;
-								if (bescheid_geben)
+								if (inform)
 									{
-										benachrichtigen(partie, "aenderung_welt", {});
+										notify(round, "aendrung_world", {});
 									}
 								else
 									{
-										// nichts tun
+										// nothing tun
 									}
 							}
 						
@@ -214,21 +218,21 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export function welt_leeren
+						export function world_clear
 							(
-								partie : typ_partie,
+								round : type_round,
-								bescheid_geben : boolean = true
+								inform : boolean = true
 							)
 							: void
 							{
-								partie.welt = mod_welt.blanko();
+								round.world = mod_world.blanko();
-								if (bescheid_geben)
+								if (inform)
 									{
-										benachrichtigen(partie, "aenderung_welt", {});
+										notify(round, "aendrung_world", {});
 									}
 								else
 									{
-										// nichts tun
+										// nothing tun
 									}
 							}
 						
@@ -236,58 +240,58 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export function figur_lesen
+						export function token_read
 							(
-								partie : typ_partie
+								round : type_round
 							)
-							: lib_fehlermonade.typ_fehlermonade<mod_figur.typ_figur>
+							: lib_errormonade.type_errormonade<mod_token.type_token>
 							{
-								return partie.figur;
+								return round.token;
 							}
 						
 						
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						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 <vidofnir@folksprak.org>
 						 */
-						export function welt_feld_wechseln
+						export function world_tile_wechseln
 							(
-								partie : typ_partie,
+								round : type_round,
-								stelle : mod_stelle.typ_stelle,
+								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);
+										mod_world.tile_wechseln(round.world, spot, umgekehrt);
-										benachrichtigen
+										notify
 											(
-												partie,
+												round,
-												"aenderung_welt",
+												"aendrung_world",
 												{
-													"art": "feld_wechseln",
+													"kind": "tile_wechseln",
-													"angaben":
+													"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 <vidofnir@folksprak.org>
 						 */
-						export function welt_feld_drehen
+						export function world_tile_rotate
 							(
-								partie : typ_partie,
+								round : type_round,
-								stelle : mod_stelle.typ_stelle,
+								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);
+										mod_world.tile_rotate(round.world, spot, inkrement);
-										benachrichtigen(partie, "aenderung_welt", {});
+										notify(round, "aendrung_world", {});
 									}
 							}
 						
@@ -322,67 +326,67 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						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;
+												round.mode = mod_mode.uncertain;
-												partie.testindex = (lib_fehlermonade.erstellen_schlicht<int>(0));
+												round.testindex = (lib_errormonade.create_just<int>(0));
-												benachrichtigen(partie, "aenderung_modus", {});
+												notify(round, "aendrung_mode", {});
 												break;
 											}
-										case mod_modus.ungewiss:
+										case mod_mode.uncertain:
 											{
-												if (! lib_fehlermonade.voll<mod_figur.typ_figur>(partie.figur))
+												if (! lib_errormonade.filled<mod_token.type_token>(round.token))
 													{
-														let test : mod_test.typ_test = mod_aufgabe.tests(partie.aufgabe)[lib_fehlermonade.lesen<int>(partie.testindex)];
+														let test : mod_test.type_test = mod_task.tests(round.task)[lib_errormonade.read<int>(round.testindex)];
-														let band : Array<mod_symbol.typ_symbol> = mod_vtm.mod_helfer.liste_kopieren<mod_symbol.typ_symbol>(mod_test.eingabe(test));
+														let tape : Array<mod_symbol.type_symbol> = mod_vtm.mod_helfer.list_copy<mod_symbol.type_symbol>(mod_test.input(test));
-														let stelle : mod_stelle.typ_stelle = mod_welt.erzeuger_finden(partie.welt);
+														let spot : mod_spot.type_spot = mod_world.erzeuger_finden(round.world);
-														partie.figur = (
+														round.token = (
-															lib_fehlermonade.erstellen_schlicht<mod_figur.typ_figur>
+															lib_errormonade.create_just<mod_token.type_token>
 																(
-																	mod_figur.erstellen
+																	mod_token.create
 																		(
-																			band,
+																			tape,
-																			stelle
+																			spot
 																		)
 																)
 														);
 													}
 												else
 													{
-														let figur : mod_figur.typ_figur = lib_fehlermonade.lesen<mod_figur.typ_figur>(partie.figur);
+														let token : mod_token.type_token = lib_errormonade.read<mod_token.type_token>(round.token);
-														let stelle : mod_stelle.typ_stelle = mod_figur.stelle_lesen(figur);
+														let spot : mod_spot.type_spot = mod_token.spot_read(token);
-														let aktor_ : lib_fehlermonade.typ_fehlermonade<mod_aktor.typ_aktor> = mod_welt.feld_holen(partie.welt, stelle);
+														let actuator_ : lib_errormonade.type_errormonade<mod_actuator.type_actuator> = mod_world.tile_get(round.world, spot);
-														let aktor : mod_aktor.typ_aktor = (
+														let actuator : mod_actuator.type_actuator = (
-															lib_fehlermonade.voll<mod_aktor.typ_aktor>(aktor_)
+															lib_errormonade.filled<mod_actuator.type_actuator>(actuator_)
-															? lib_fehlermonade.lesen<mod_aktor.typ_aktor>(aktor_)
+															? lib_errormonade.read<mod_actuator.type_actuator>(actuator_)
-															: mod_aktor.mod_verwerfer.erstellen_aktor()
+															: mod_actuator.mod_verwerfer.create_actuator()
 														);
-														mod_aktor.verwenden(aktor, figur);
+														mod_actuator.use(actuator, token);
-														let zustand : mod_zustand.typ_zustand = mod_figur.zustand_lesen(figur);
+														let state : mod_state.type_state = mod_token.state_read(token);
-														if (zustand === mod_zustand.laufend)
+														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 accepted : boolean = (state === mod_state.accepted);
-																let ausgabe : Array<mod_symbol.typ_symbol> = mod_figur.band_lesen(figur);
+																let ausgabe : Array<mod_symbol.type_symbol> = mod_token.tape_read(token);
-																partie.figur = (lib_fehlermonade.erstellen_nichts<mod_figur.typ_figur>());
+																round.token = (lib_errormonade.create_nothing<mod_token.type_token>());
-																let testindex : int = lib_fehlermonade.lesen<int>(partie.testindex);
+																let testindex : int = lib_errormonade.read<int>(round.testindex);
-																let tests : Array<mod_test.typ_test> = mod_aufgabe.tests(partie.aufgabe);
+																let tests : Array<mod_test.type_test> = mod_task.tests(round.task);
-																let test : mod_test.typ_test = tests[testindex];
+																let test : mod_test.type_test = tests[testindex];
-																if (! mod_test.pruefen(test, angenommen, ausgabe))
+																if (! mod_test.pruefen(test, accepted, ausgabe))
 																	{
-																		partie.modus = mod_modus.fehlerhaft;
+																		round.mode = mod_mode.wrong;
-																		benachrichtigen(partie, "aenderung_modus", {});
+																		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<int>(testindex));
+																				round.testindex = (lib_errormonade.create_just<int>(testindex));
 																			}
 																		else
 																			{
-																				// auf Modus "korrekt" wechseln
+																				// auf Modus "correct" wechseln
-																				partie.testindex = (lib_fehlermonade.erstellen_nichts<int>());
+																				round.testindex = (lib_errormonade.create_nothing<int>());
-																				partie.modus = mod_modus.korrekt;
+																				round.mode = mod_mode.correct;
-																				benachrichtigen(partie, "aenderung_modus", {});
+																				notify(round, "aendrung_mode", {});
 																			}
 																	}
 															}
 														else
 															{
-																let meldung : string = "unbehandelter Zustand";
+																let message : string = "unbehandelter Zustand";
-																throw (new Error(meldung));
+																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";
+												let message : string = "unbehandelter Modus";
-												throw (new Error(meldung));
+												throw (new Error(message));
 												break;
 											}
 									}

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 <vidofnir@folksprak.org>
 						 */
-						export type typ_richtung = int;
+						export type type_direction = int;
 						
 						
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						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 <vidofnir@folksprak.org>
 						 */
-						export function exportieren(richtung : typ_richtung) : int
+						export function export_(direction : type_direction) : int
 							{
-								return richtung;
+								return direction;
 							}
 						
 						
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export function importieren(richtung_ : int) : typ_richtung
+						export function import_(direction_ : int) : type_direction
 							{
-								return richtung_;
+								return direction_;
 							}
 						
 					}

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 <vidofnir@folksprak.org>
 						 */
-						export type typ_stelle = {u : int; v : int;};
+						export type type_spot = {u : int; v : int;};
 						
 						
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						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 <vidofnir@folksprak.org>
 						 */
-						export function von_hash(hash : string) : typ_stelle
+						export function von_hash(hash : string) : type_spot
 							{
 								let teile : Array<string> = hash.split("_");
 								return {"u": parseInt(teile[0]), "v": parseInt(teile[1])};
@@ -53,7 +53,7 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export function null_() : typ_stelle
+						export function null_() : type_spot
 							{
 								return {"u": 0, "v": 0};
 							}
@@ -62,9 +62,9 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						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 <vidofnir@folksprak.org>
 						 */
-						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 <vidofnir@folksprak.org>
 						 */
-						export function exportieren(stelle : typ_stelle) : string
+						export function export_(spot : type_spot) : string
 							{
-								return hash(stelle);
+								return hash(spot);
 							}
 						
 						
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export function importieren(stelle_ : string) : typ_stelle
+						export function import_(spot_ : string) : type_spot
 							{
-								return von_hash(stelle_);
+								return von_hash(spot_);
 							}
 								
 					}

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 <vidofnir@folksprak.org>
 						 */
-						export type typ_symbol = int;
+						export type type_symbol = int;
 						
 						
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						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 <vidofnir@folksprak.org>
 						 */
-						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 <vidofnir@folksprak.org>
 						 */
-						export function importieren(symbol_ : int) : typ_symbol
+						export function import_(symbol_ : int) : type_symbol
 							{
 								return symbol_;
 							}

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 <vidofnir@folksprak.org>
 						 */
-						export type typ_welt =
+						export type type_world =
 							{
-								felder : lib_hashmap.typ_hashmap<mod_stelle.typ_stelle, mod_aktor.typ_aktor>;
+								tiles : lib_hashmap.type_hashmap<mod_spot.type_spot, mod_actuator.type_actuator>;
 							}
 						;
 						
@@ -38,14 +38,14 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export function erstellen
+						export function create
 							(
-								felder : lib_hashmap.typ_hashmap<mod_stelle.typ_stelle, mod_aktor.typ_aktor> = lib_hashmap.erstellen<mod_stelle.typ_stelle, mod_aktor.typ_aktor>(mod_stelle.hash)
+								tiles : lib_hashmap.type_hashmap<mod_spot.type_spot, mod_actuator.type_actuator> = lib_hashmap.create<mod_spot.type_spot, mod_actuator.type_actuator>(mod_spot.hash)
 							)
-							: typ_welt
+							: type_world
 							{
 								return {
-									"felder": felder,
+									"tiles": tiles,
 								};
 							}
 						
@@ -53,86 +53,86 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						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;}> = [];
+								let tiles : Array<{spot : mod_spot.type_spot; actuator : mod_actuator.type_actuator;}> = [];
-								 lib_hashmap.iterieren
+								 lib_hashmap.iterate
 									(
-										welt.felder,
+										world.tiles,
-										(stelle, aktor) => felder.push({"stelle": stelle, "aktor": aktor})
+										(spot, actuator) => tiles.push({"spot": spot, "actuator": actuator})
 									)
 								;
-								return felder;
+								return tiles;
 							}
 						
 						
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export function feld_holen
+						export function tile_get
 							(
-								welt : typ_welt,
+								world : type_world,
-								stelle : mod_stelle.typ_stelle
+								spot : mod_spot.type_spot
 							)
-							: lib_fehlermonade.typ_fehlermonade<mod_aktor.typ_aktor>
+							: lib_errormonade.type_errormonade<mod_actuator.type_actuator>
 							{
-								return lib_hashmap.holen(welt.felder, stelle);
+								return lib_hashmap.get(world.tiles, spot);
 							}
 						
 						
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export function feld_setzen
+						export function tile_set
 							(
-								welt : typ_welt,
+								world : type_world,
-								stelle : mod_stelle.typ_stelle,
+								spot : mod_spot.type_spot,
-								aktor : mod_aktor.typ_aktor
+								actuator : mod_actuator.type_actuator
 							)
 							: void
 							{
-								lib_hashmap.setzen(welt.felder, stelle, aktor);
+								lib_hashmap.set(world.tiles, spot, actuator);
 							}
 						
 						
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export function feld_wechseln
+						export function tile_wechseln
 							(
-								welt : typ_welt,
+								world : type_world,
-								stelle : mod_stelle.typ_stelle,
+								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"),
+													"pruefer": (actuator) => (actuator.kind === "befoerderer"),
-													"ersteller": () => mod_aktor.mod_befoerderer.erstellen_aktor(0),
+													"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_links : mod_symbol.type_symbol = (2*index+0);
-															let symbol_rechts : mod_symbol.typ_symbol = (2*index+1);
+															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"),
+													"pruefer": (actuator) => (actuator.kind === "verwerfer"),
-													"ersteller": () => mod_aktor.mod_verwerfer.erstellen_aktor(),
+													"erspotr": () => mod_actuator.mod_verwerfer.create_actuator(),
 												},
 											]
 										)
 								);
-								let index_alt : lib_fehlermonade.typ_fehlermonade<int>;
+								let index_alt : lib_errormonade.type_errormonade<int>;
-								let aktor_alt_ : lib_fehlermonade.typ_fehlermonade<mod_aktor.typ_aktor> = lib_hashmap.holen(welt.felder, stelle);
+								let actuator_alt_ : lib_errormonade.type_errormonade<mod_actuator.type_actuator> = lib_hashmap.get(world.tiles, spot);
-								if (lib_fehlermonade.voll<mod_aktor.typ_aktor>(aktor_alt_))
+								if (lib_errormonade.filled<mod_actuator.type_actuator>(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<int>(index));
+																	index_alt = (lib_errormonade.create_just<int>(index));
 																	return true;
 																}
 															else
@@ -211,30 +211,30 @@ module mod_vtm
 										);
 										if (! gefunden)
 											{
-												index_alt = (lib_fehlermonade.erstellen_nichts<int>());
+												index_alt = (lib_errormonade.create_nothing<int>());
 											}
 										else
 											{
-												// nichts tun
+												// nothing tun
 											}
 									}
 								else
 									{
-										let meldung : string = "kein Aktor gesetzt";
+										let message : string = "kein Aktor gesetzt";
-										// console.warn(meldung);
+										// console.warn(message);
-										index_alt = (lib_fehlermonade.erstellen_schlicht<int>(0));
+										index_alt = (lib_errormonade.create_just<int>(0));
 									}
-								if (lib_fehlermonade.voll<int>(index_alt))
+								if (lib_errormonade.filled<int>(index_alt))
 									{
-										let index_neu : int = lib_mathematik.mod(lib_fehlermonade.lesen<int>(index_alt) + (umgekehrt ? -1 : +1), liste.length);
+										let index_neu : int = lib_math.mod(lib_errormonade.read<int>(index_alt) + (umgekehrt ? -1 : +1), liste.length);
-										let aktor_neu : mod_aktor.typ_aktor = liste[index_neu].ersteller();
+										let actuator_neu : mod_actuator.type_actuator = liste[index_neu].erspotr();
-										feld_setzen(welt, stelle, aktor_neu);
+										tile_set(world, spot, actuator_neu);
 									}
 								else
 									{
-										let meldung : string = ("Aktor nicht gefunden");
+										let message : string = ("Aktor nicht gefunden");
-										// throw (new Error(meldung));
+										// throw (new Error(message));
-										console.warn(meldung);
+										console.warn(message);
 									}
 							}
 						
@@ -242,18 +242,18 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export function feld_drehen
+						export function tile_rotate
 							(
-								welt : typ_welt,
+								world : type_world,
-								stelle : mod_stelle.typ_stelle,
+								spot : mod_spot.type_spot,
 								inkrement : int = +1
 							)
 							: void
 							{
-								let aktor_ : lib_fehlermonade.typ_fehlermonade<mod_aktor.typ_aktor> = lib_hashmap.holen(welt.felder, stelle);
+								let actuator_ : lib_errormonade.type_errormonade<mod_actuator.type_actuator> = lib_hashmap.get(world.tiles, spot);
-								if (lib_fehlermonade.voll<mod_aktor.typ_aktor>(aktor_))
+								if (lib_errormonade.filled<mod_actuator.type_actuator>(actuator_))
 									{
-										mod_aktor.drehen(lib_fehlermonade.lesen<mod_aktor.typ_aktor>(aktor_), inkrement);
+										mod_actuator.rotate(lib_errormonade.read<mod_actuator.type_actuator>(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<mod_stelle.typ_stelle> = (lib_fehlermonade.erstellen_nichts<mod_stelle.typ_stelle>());
+								let spot : lib_errormonade.type_errormonade<mod_spot.type_spot> = (lib_errormonade.create_nothing<mod_spot.type_spot>());
-								lib_hashmap.iterieren
+								lib_hashmap.iterate
 									(
-										welt.felder,
+										world.tiles,
-										(stelle_, aktor) =>
+										(spot_, actuator) =>
 											{
-												if (aktor.art === "erzeuger")
+												if (actuator.kind === "erzeuger")
 													{
-														if (lib_fehlermonade.voll<mod_stelle.typ_stelle>(stelle))
+														if (lib_errormonade.filled<mod_spot.type_spot>(spot))
 															{
-																let meldung : string = "mehrere Erzeuger gefunden";
+																let message : string = "mehrere Erzeuger gefunden";
-																throw (new Error(meldung));
+																throw (new Error(message));
 															}
 														else
 															{
-																stelle = (lib_fehlermonade.erstellen_schlicht<mod_stelle.typ_stelle>(stelle_));
+																spot = (lib_errormonade.create_just<mod_spot.type_spot>(spot_));
 															}
 													}
 											}
 									)
 								;
-								if (lib_fehlermonade.voll<mod_stelle.typ_stelle>(stelle))
+								if (lib_errormonade.filled<mod_spot.type_spot>(spot))
 									{
-										return lib_fehlermonade.lesen<mod_stelle.typ_stelle>(stelle);
+										return lib_errormonade.read<mod_spot.type_spot>(spot);
 									}
 								else
 									{
-										let meldung : string = "kein Erzeuger gefunden";
+										let message : string = "kein Erzeuger gefunden";
-										throw (new Error(meldung));
+										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 spot : mod_spot.type_spot = {"u": u, "v": v};
-														let aktor : mod_aktor.typ_aktor;
+														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 <vidofnir@folksprak.org>
 						 */
-						export function exportieren
+						export function export_
 							(
-								welt : typ_welt
+								world : type_world
 							)
 							: any
 							{
-								let roh : any = {};
+								let raw : any = {};
-								roh["felder"] = {};
+								raw["tiles"] = {};
-								lib_hashmap.iterieren
+								lib_hashmap.iterate
 									(
-										welt.felder,
+										world.tiles,
-										(stelle, aktor) =>
+										(spot, actuator) =>
 											{
-												let stelle_ : string = mod_stelle.exportieren(stelle);
+												let spot_ : string = mod_spot.export_(spot);
-												let aktor_ : any = mod_aktor.exportieren(aktor);
+												let actuator_ : any = mod_actuator.export_(actuator);
-												roh["felder"][stelle_] = aktor_;
+												raw["tiles"][spot_] = actuator_;
 											}
 									)
 								;
-								return roh;
+								return raw;
 							}
 						
 						
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export function importieren
+						export function import_
 							(
-								roh : any
+								raw : any
 							)
-							: typ_welt
+							: type_world
 							{
-								let felder : lib_hashmap.typ_hashmap<mod_stelle.typ_stelle, mod_aktor.typ_aktor> = (lib_hashmap.erstellen<mod_stelle.typ_stelle, mod_aktor.typ_aktor>(mod_stelle.hash));
+								let tiles : lib_hashmap.type_hashmap<mod_spot.type_spot, mod_actuator.type_actuator> = (lib_hashmap.create<mod_spot.type_spot, mod_actuator.type_actuator>(mod_spot.hash));
-								for (let stelle_ in roh["felder"])
+								for (let spot_ in raw["tiles"])
 									{
-										let stelle : mod_stelle.typ_stelle = mod_stelle.importieren(stelle_);
+										let spot : mod_spot.type_spot = mod_spot.import_(spot_);
-										let aktor_ : mod_aktor.typ_aktor = roh["felder"][stelle_];
+										let actuator_ : mod_actuator.type_actuator = raw["tiles"][spot_];
-										let aktor : mod_aktor.typ_aktor = mod_aktor.importieren(aktor_);
+										let actuator : mod_actuator.type_actuator = mod_actuator.import_(actuator_);
-										lib_hashmap.setzen(felder, stelle, aktor);
+										lib_hashmap.set(tiles, spot, actuator);
 									}
 								return (
-									erstellen
+									create
 										(
-											felder
+											tiles
 										)
 								);
 							}

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 <vidofnir@folksprak.org>
 						 */
-						export type typ_zustand = int;
+						export type type_state = int;
 						
 						
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export var abgelehnt = -1;
+						export var rejected = -1;
-						export var laufend = 0;
+						export var running = 0;
-						export var angenommen = +1;
+						export var accepted = +1;
 					
 					}
 				

quelldatein/daten.ts

@@ -19,36 +19,36 @@
 module mod_vtm
 	{
 		
-		export module mod_daten
+		export module mod_data
 			{
 					
 				/**
 				 * @author kcf <vidofnir@folksprak.org>
 				 */
-				var _speicher = {};
+				var _store = {};
 				
 				
 				/**
 				 * @author kcf <vidofnir@folksprak.org>
 				 */
-				export function schreiben(schluessel : string, wert : any) : void
+				export function write(key : string, value : any) : void
 					{
-						_speicher[schluessel] = wert;
+						_store[key] = value;
 					}
 				
 				
 				/**
 				 * @author kcf <vidofnir@folksprak.org>
 				 */
-				export function lesen(schluessel : string) : lib_fehlermonade.typ_fehlermonade<any>
+				export function read(key : string) : lib_errormonade.type_errormonade<any>
 					{
-						if (schluessel in _speicher)
+						if (key in _store)
 							{
-								return (lib_fehlermonade.erstellen_schlicht<any>(_speicher[schluessel]));
+								return (lib_errormonade.create_just<any>(_store[key]));
 							}
 						else
 							{
-								return (lib_fehlermonade.erstellen_nichts<any>());
+								return (lib_errormonade.create_nothing<any>());
 							}
 					}
 				
@@ -60,8 +60,8 @@ module mod_vtm
 /**
  * @author kcf <vidofnir@folksprak.org>
  */
-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);
 	}
 

quelldatein/daten/aufgaben.dat.js

@@ -1,253 +1,253 @@
-jsonp_behandlung(
+jsonp_handle(
 	{
-		"schluessel": "aufgaben",
+		"key": "tasks",
-		"wert": [
+		"value": [
 			{
 				"id": "einfuehrung",
-				"art": "akzeptor",
+				"kind": "acceptor",
 				"parameter": {
 					"titel": "Einführung",
 					"text": "Bewege die Figur vom Eingang (links) zum Ausgang (rechts)!",
 					"tests": [
 						{
-							"eingabe": [],
+							"input": [],
-							"annehmen": true
+							"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": [],
+							"input": [],
-							"annehmen": false
+							"accept": false
 						},
 						{
-							"eingabe": [0],
+							"input": [0],
-							"annehmen": false
+							"accept": false
 						},
 						{
-							"eingabe": [1],
+							"input": [1],
-							"annehmen": true
+							"accept": true
 						},
 						{
-							"eingabe": [0,1],
+							"input": [0,1],
-							"annehmen": false
+							"accept": false
 						},
 						{
-							"eingabe": [1,0,1,1,0,0,0,1,0],
+							"input": [1,0,1,1,0,0,0,1,0],
-							"annehmen": true
+							"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],
+							"input": [1],
-							"annehmen": false
+							"accept": false
 						},
 						{
-							"eingabe": [0,0,1,1],
+							"input": [0,0,1,1],
-							"annehmen": false
+							"accept": false
 						},
 						{
-							"eingabe": [1,0,1,0,0,1,0],
+							"input": [1,0,1,0,0,1,0],
-							"annehmen": true
+							"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": [],
+							"input": [],
-							"annehmen": true
+							"accept": true
 						},
 						{
-							"eingabe": [0],
+							"input": [0],
-							"annehmen": true
+							"accept": true
 						},
 						{
-							"eingabe": [0,0],
+							"input": [0,0],
-							"annehmen": false
+							"accept": false
 						},
 						{
-							"eingabe": [1,0,1],
+							"input": [1,0,1],
-							"annehmen": true
+							"accept": true
 						},
 						{
-							"eingabe": [0,1,0,1,0,1],
+							"input": [0,1,0,1,0,1],
-							"annehmen": true
+							"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],
+							"input": [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]
+							"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],
+							"input": [0,1,1,0],
-							"ausgabe": [2,3,3,2]
+							"output": [2,3,3,2]
 						},
 						{
-							"eingabe": [0,1,0,1,0,1,1,0,0,0,0,1,0,1,1,0],
+							"input": [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]
+							"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],
+							"input": [0,0,0,1,0],
-							"ausgabe": [1]
+							"output": [1]
 						},
 						{
-							"eingabe": [1,0,1,0,1],
+							"input": [1,0,1,0,1],
-							"ausgabe": [1,1,1]
+							"output": [1,1,1]
 						},
 						{
-							"eingabe": [1,1,1,1,0],
+							"input": [1,1,1,1,0],
-							"ausgabe": [1,1,1,1]
+							"output": [1,1,1,1]
 						},
 						{
-							"eingabe": [0,0,0,0,1,0,1,1,0],
+							"input": [0,0,0,0,1,0,1,1,0],
-							"ausgabe": [1,1,1]
+							"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],
+							"input": [1,1,0],
-							"ausgabe": [2,1,1,0,3]
+							"output": [2,1,1,0,3]
 						},
 						{
-							"eingabe": [0,0,1,0,0],
+							"input": [0,0,1,0,0],
-							"ausgabe": [2,0,0,1,0,0,3]
+							"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": [],
+							"input": [],
-							"annehmen": true
+							"accept": true
 						},
 						{
-							"eingabe": [1],
+							"input": [1],
-							"annehmen": true
+							"accept": true
 						},
 						{
-							"eingabe": [0,1],
+							"input": [0,1],
-							"annehmen": false
+							"accept": false
 						},
 						{
-							"eingabe": [0,1,1,1,0],
+							"input": [0,1,1,1,0],
-							"annehmen": true
+							"accept": true
 						},
 						{
-							"eingabe": [1,1,0,0],
+							"input": [1,1,0,0],
-							"annehmen": false
+							"accept": false
 						},
 						{
-							"eingabe": [1,0,1,1,1],
+							"input": [1,0,1,1,1],
-							"annehmen": true
+							"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],
+							"input": [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]
+							"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": [],
+							"input": [],
-							"annehmen": true
+							"accept": true
 						},
 						{
-							"eingabe": [0],
+							"input": [0],
-							"annehmen": false
+							"accept": false
 						},
 						{
-							"eingabe": [0,0,1,1],
+							"input": [0,0,1,1],
-							"annehmen": true
+							"accept": true
 						},
 						{
-							"eingabe": [0,0,0,1,1],
+							"input": [0,0,0,1,1],
-							"annehmen": false
+							"accept": false
 						},
 						{
-							"eingabe": [0,0,0,0,0,0,0,1,1,1,1,1,1,1],
+							"input": [0,0,0,0,0,0,0,1,1,1,1,1,1,1],
-							"annehmen": true
+							"accept": true
 						}
 					],
 					"hinweise": [

quelldatein/daten/zeichenketten/de.dat.js

@@ -1,50 +1,54 @@
-jsonp_behandlung(
+jsonp_handle(
 	{
-		"schluessel": "zeichenketten-de",
+		"key": "strings-de",
-		"wert": {
+		"value": {
-			"allgemein.titel": "Verrückte Turing-Maschinen",
+			"common.title": "Verrückte Turing-Maschinen",
-			"allgemein.hilfe": "Hilfe",
+			"common.help": "Hilfe",
-			"allgemein.spiel": "Spiel",
+			"common.game": "Spiel",
-			"aufbau.figur.worter.singular": "Figur",
+			"model.token.terms.singular": "Figur",
-			"aufbau.figur.worter.plural": "Figuren",
+			"model.token.terms.plural": "Figuren",
-			"aufbau.aktoren.woerter.singular": "Aktor",
+			"model.modes.initial": "Maschine bearbeiten",
-			"aufbau.aktoren.woerter.plural": "Aktoren",
+			"model.modes.uncertain": "wird geprüft …",
-			"aufbau.aktoren.arten.erzeuger.name": "Eingang",
+			"model.modes.wrong": "fehlerhaft :/",
-			"aufbau.aktoren.arten.annehmer.name": "Ausgang",
+			"model.modes.correct": "anscheinend korrekt :)",
-			"aufbau.aktoren.arten.verwerfer.name": "Abweiser",
+			"model.actuators.terms.singular": "Aktor",
-			"aufbau.aktoren.arten.befoerderer.name": "Schieber",
+			"model.actuators.terms.plural": "Aktoren",
-			"aufbau.aktoren.arten.schreiber.name": "Schreiber",
+			"model.actuators.kinds.erzeuger.name": "Eingang",
-			"aufbau.aktoren.arten.leser.name": "Weiche",
+			"model.actuators.kinds.annehmer.name": "Ausgang",
-			"aufbau.aufgaben.woerter.singular": "Aufgabe",
+			"model.actuators.kinds.verwerfer.name": "Abweiser",
-			"aufbau.aufgaben.woerter.plural": "Aufgaben",
+			"model.actuators.kinds.befoerderer.name": "Schieber",
-			"aufbau.aufgaben.arten.akzeptor.name": "Akzeptor",
+			"model.actuators.kinds.schreiber.name": "Schreiber",
-			"aufbau.aufgaben.arten.akzeptor.kuerzel": "AKZ",
+			"model.actuators.kinds.leser.name": "Weiche",
-			"aufbau.aufgaben.arten.transduktor.name": "Transduktor",
+			"model.tasks.terms.singular": "Aufgabe",
-			"aufbau.aufgaben.arten.transduktor.kuerzel": "TRA",
+			"model.tasks.terms.plural": "tasks",
-			"steuerung.auswaehlen": "Aufgabe auswählen",
+			"model.tasks.kinds.acceptor.name": "Akzeptor",
-			"steuerung.schritt": "Nächster Schritt",
+			"model.tasks.kinds.acceptor.shortcut": "AKZ",
-			"steuerung.test": "Ablaufen",
+			"model.tasks.kinds.transductor.name": "Transduktor",
-			"steuerung.anhalten": "Anhalten",
+			"model.tasks.kinds.transductor.shortcut": "TRA",
-			"steuerung.bearbeiten": "Bearbeiten",
+			"controls.choose": "Aufgabe auswählen",
-			"steuerung.leeren": "Leeren",
+			"controls.step": "Nächster Schritt",
-			"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",
+			"controls.run": "Ablaufen",
-			"hilfe.steuerung.titel": "Steuerung",
+			"controls.stop": "Anhalten",
-			"hilfe.steuerung.eintrag1": "Links-Klick/Rechts-Klick: Feldtyp wechseln",
+			"controls.edit": "Bearbeiten",
-			"hilfe.steuerung.eintrag2": "Mausrad-Drehen: Feld drehen",
+			"controls.clear": "Leeren",
-			"hilfe.figur.satz1": "Die Figur kann durch Aktoren auf dem Spielplan umher bewegt werden und wird als schwarzer Kreis dargestellt.",
+			"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",
-			"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).",
+			"help.controls.title": "Steuerung",
-			"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:",
+			"help.controls.eintrag1": "Links-Klick/Rechts-Klick: Feldtyp wechseln",
-			"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.",
+			"help.controls.eintrag2": "Mausrad-Drehen: Feld drehen",
-			"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.",
+			"help.token.satz1": "Die Figur kann durch Aktoren auf dem Spielplan umher bewegt werden und wird als schwarzer Kreis dargestellt.",
-			"hilfe.aktoren.verwerfer": "Jedes leere Feld beendet den Lauf der Figur mit einer Abweisung des aktuellen Band-Inhalts.",
+			"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).",
-			"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.",
+			"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:",
-			"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.",
+			"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.",
-			"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.",
+			"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.",
-			"hilfe.aufgaben.einleitung": "Ziel ist das Lösen von bestimmten Aufgaben. Dabei wird zwischen zwei Arten von Aufgaben unterschieden:",
+			"help.actuators.verwerfer": "Jedes leere Feld beendet den Lauf der Figur mit einer Abweisung des aktuellen Band-Inhalts.",
-			"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.",
+			"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.",
-			"hilfe.aufgaben.akzeptor.beispiel": "Beispiel: Genau dann akzeptieren, wenn das Band mindestens zwei mal rot enthält.",
+			"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.",
-			"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.",
+			"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.",
-			"hilfe.aufgaben.transduktor.beispiel": "Beispiel: Die Eingabe zwei mal wiederholt."
+			"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."
 		}
 	}
 );

quelldatein/daten/zeichenketten/en.dat.js

@@ -1,50 +1,54 @@
-jsonp_behandlung(
+jsonp_handle(
 	{
-		"schluessel": "zeichenketten-en",
+		"key": "strings-en",
-		"wert": {
+		"value": {
-			"allgemein.titel": "Crazy Turing Machines",
+			"common.title": "Crazy Turing Machines",
-			"allgemein.hilfe": "Help",
+			"common.help": "Help",
-			"allgemein.spiel": "Game",
+			"common.game": "Game",
-			"aufbau.figur.worter.singular": "token",
+			"model.token.terms.singular": "token",
-			"aufbau.figur.worter.plural": "tokens",
+			"model.token.terms.plural": "tokens",
-			"aufbau.aktoren.woerter.singular": "actor",
+			"model.modes.initial": "edit machine",
-			"aufbau.aktoren.woerter.plural": "actors",
+			"model.modes.uncertain": "testing …",
-			"aufbau.aktoren.arten.erzeuger.name": "entrance",
+			"model.modes.wrong": "flawed :/",
-			"aufbau.aktoren.arten.annehmer.name": "exit",
+			"model.modes.correct": "seemingly correct :)",
-			"aufbau.aktoren.arten.verwerfer.name": "dropper",
+			"model.actuators.terms.singular": "actor",
-			"aufbau.aktoren.arten.befoerderer.name": "conveyer",
+			"model.actuators.terms.plural": "actors",
-			"aufbau.aktoren.arten.schreiber.name": "writer",
+			"model.actuators.kinds.erzeuger.name": "entrance",
-			"aufbau.aktoren.arten.leser.name": "switch",
+			"model.actuators.kinds.annehmer.name": "exit",
-			"aufbau.aufgaben.woerter.singular": "task",
+			"model.actuators.kinds.verwerfer.name": "dropper",
-			"aufbau.aufgaben.woerter.plural": "tasks",
+			"model.actuators.kinds.befoerderer.name": "conveyer",
-			"aufbau.aufgaben.arten.akzeptor.name": "acceptor",
+			"model.actuators.kinds.schreiber.name": "writer",
-			"aufbau.aufgaben.arten.akzeptor.kuerzel": "ACC",
+			"model.actuators.kinds.leser.name": "switch",
-			"aufbau.aufgaben.arten.transduktor.name": "transductor",
+			"model.tasks.terms.singular": "task",
-			"aufbau.aufgaben.arten.transduktor.kuerzel": "TRA",
+			"model.tasks.terms.plural": "tasks",
-			"steuerung.auswaehlen": "choose task",
+			"model.tasks.kinds.acceptor.name": "acceptor",
-			"steuerung.schritt": "next step",
+			"model.tasks.kinds.acceptor.shortcut": "ACC",
-			"steuerung.test": "run",
+			"model.tasks.kinds.transductor.name": "transductor",
-			"steuerung.anhalten": "stop",
+			"model.tasks.kinds.transductor.shortcut": "TRA",
-			"steuerung.bearbeiten": "edit",
+			"controls.choose": "choose task",
-			"steuerung.leeren": "clear",
+			"controls.step": "next step",
-			"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",
+			"controls.run": "run",
-			"hilfe.steuerung.titel": "controls",
+			"controls.stop": "stop",
-			"hilfe.steuerung.eintrag1": "left click/right click: change tile type",
+			"controls.edit": "edit",
-			"hilfe.steuerung.eintrag2": "rotate mousewheel: rotate tile",
+			"controls.clear": "clear",
-			"hilfe.figur.satz1": "The token can be moved around the board by actors and it is displayed as a black circle.",
+			"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",
-			"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).",
+			"help.controls.title": "controls",
-			"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:",
+			"help.controls.eintrag1": "left click/right click: change tile type",
-			"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.",
+			"help.controls.eintrag2": "rotate mousewheel: rotate tile",
-			"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.",
+			"help.token.satz1": "The token can be moved around the board by actors and it is displayed as a black circle.",
-			"hilfe.aktoren.verwerfer": "Every empty tile will cancel the tokens run with a rejection of the current tape content.",
+			"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).",
-			"hilfe.aktoren.befoerderer": "This actor is used for moving the token to neighbour tile without changing the tape content.",
+			"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:",
-			"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.",
+			"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.",
-			"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.",
+			"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.",
-			"hilfe.aufgaben.einleitung": "The goal is to solve certain tasks. Two kind of tasks are distinguished:",
+			"help.actuators.verwerfer": "Every empty tile will cancel the tokens run with a rejection of the current tape content.",
-			"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.",
+			"help.actuators.befoerderer": "This actor is used for moving the token to neighbour tile without changing the tape content.",
-			"hilfe.aufgaben.akzeptor.beispiel": "Example: Accept then and only then, if the tape contains at least two red symbols.",
+			"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.",
-			"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.",
+			"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.",
-			"hilfe.aufgaben.transduktor.beispiel": "Example: The input repeated two times."
+			"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."
 		}
 	}
 );

quelldatein/haupt.ts

@@ -22,49 +22,49 @@ module mod_vtm
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		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<Array<any>> = mod_vtm.mod_daten.lesen("aufgaben");
+				let tasks_raw_ : lib_errormonade.type_errormonade<Array<any>> = mod_vtm.mod_data.read("tasks");
-				if (lib_fehlermonade.voll(aufgaben_roh_))
+				if (lib_errormonade.filled(tasks_raw_))
 					{
-						let aufgaben_roh : Array<any> = lib_fehlermonade.lesen(aufgaben_roh_);
+						let tasks_raw : Array<any> = lib_errormonade.read(tasks_raw_);
-						let dom_auswahl : Element = document.querySelector("#aufgabe_auswahl");
+						let dom_selection : Element = document.querySelector("#task_selection");
-						aufgaben_roh.forEach
+						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);
+											let task : mod_model.mod_task.type_task = mod_model.mod_task.import_(task_raw);
-											mod_aufbau.mod_aufgabe.registrieren(aufgabe);
+											mod_model.mod_task.registrieren(task);
 										}
-										// Option eintragen
+										// Option insert
 										{
 											let praefix : string = (
 												{
-													"akzeptor": lib_uebersetzung.holen("aufbau.aufgaben.arten.akzeptor.kuerzel"),
+													"acceptor": lib_translate.get("model.tasks.kinds.acceptor.shortcut"),
-													"transduktor": lib_uebersetzung.holen("aufbau.aufgaben.arten.transduktor.kuerzel"),
+													"transductor": lib_translate.get("model.tasks.kinds.transductor.shortcut"),
-												}[aufgabe_roh["art"]]
+												}[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);
+										let task : mod_model.mod_task.type_task = mod_model.mod_task.get(index);
-										behandler(aufgabe);
+										behandler(task);
 									}
 							)
 						;
@@ -79,25 +79,25 @@ module mod_vtm
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		function haupt() : void
+		function main() : void
 			{
 				// Übersetzungen
 				{
-					let sprachen : Array<string> = navigator.languages.map(sprache => sprache);
+					let languages : Array<string> = navigator.languages.map(language => language);
-					let sprache_nativ : string = "de";
+					let language_nativ : string = "de";
-					if (! sprachen[""+"includes"](sprache_nativ))
+					if (! languages[""+"includes"](language_nativ))
-						sprachen.push(sprache_nativ);
+						languages.push(language_nativ);
-					lib_uebersetzung.einrichten(sprachen);
+					lib_translate.setup(languages);
-					lib_uebersetzung.anwenden(document);
+					lib_translate.deploy(document);
 				}
 				// Hilfe
 				{
 					// Einleitung
 					{
-						document.querySelector("#hilfe_einleitung").innerHTML = (
+						document.querySelector("#help_introduction").innerHTML = (
-							lib_uebersetzung.holen
+							lib_translate.get
 								(
-									"hilfe.einleitung",
+									"help.introduction",
 									{
 										"manufacturia": "<a href=\"http://www.kongregate.com/games/PleasingFungus/manufactoria\">Manufacturia</a>",
 										"crazy_machines": "<a href=\"http://www.crazy-machines.com/\">Crazy Machines</a>",
@@ -118,28 +118,28 @@ module mod_vtm
 							let hoehe : float = 80;
 							[
 								{
-									"aufbau": mod_aufbau.mod_aktor.beispiel("erzeuger"),
+									"model": mod_model.mod_actuator.example("erzeuger"),
-									"bereich": document.querySelector("#hilfe_aktoren_aktor_erzeuger"),
+									"bereich": document.querySelector("#help_actuators_actuator_erzeuger"),
 								},
 								{
-									"aufbau": mod_aufbau.mod_aktor.beispiel("annehmer"),
+									"model": mod_model.mod_actuator.example("annehmer"),
-									"bereich": document.querySelector("#hilfe_aktoren_aktor_annehmer"),
+									"bereich": document.querySelector("#help_actuators_actuator_annehmer"),
 								},
 								{
-									"aufbau": mod_aufbau.mod_aktor.beispiel("verwerfer"),
+									"model": mod_model.mod_actuator.example("verwerfer"),
-									"bereich": document.querySelector("#hilfe_aktoren_aktor_verwerfer"),
+									"bereich": document.querySelector("#help_actuators_actuator_verwerfer"),
 								},
 								{
-									"aufbau": mod_aufbau.mod_aktor.beispiel("befoerderer"),
+									"model": mod_model.mod_actuator.example("befoerderer"),
-									"bereich": document.querySelector("#hilfe_aktoren_aktor_befoerderer"),
+									"bereich": document.querySelector("#help_actuators_actuator_befoerderer"),
 								},
 								{
-									"aufbau": mod_aufbau.mod_aktor.beispiel("schreiber"),
+									"model": mod_model.mod_actuator.example("schreiber"),
-									"bereich": document.querySelector("#hilfe_aktoren_aktor_schreiber"),
+									"bereich": document.querySelector("#help_actuators_actuator_schreiber"),
 								},
 								{
-									"aufbau": mod_aufbau.mod_aktor.beispiel("leser"),
+									"model": mod_model.mod_actuator.example("leser"),
-									"bereich": document.querySelector("#hilfe_aktoren_aktor_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,
+														eintrag.model,
-														mod_aufbau.mod_stelle.null_()
+														mod_model.mod_spot.null_()
 													)
 											);
-											let xmlknoten : lib_xml.typ_knoten = (
+											let xmlnode : lib_xml.type_node = (
-												mod_manifestation.mod_svg.wurzel
+												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,
+									round,
-									document.querySelector("#bereich_mitte")
+									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 <vidofnir@folksprak.org>
 		 */
-		export function eingang_web() : void
+		export function entry_web() : void
 			{
 				document.addEventListener
 					(
 						"DOMContentLoaded",
-						event => {haupt();}
+						event => {main();}
 					)
 				;
 			}

quelldatein/helfer/aufruf.ts

@@ -16,56 +16,56 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-module lib_aufruf
+module lib_call
 	{
 
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		export type typ_komplex<typ_angaben> = {art : string; angaben : typ_angaben;};
+		export type type_complex<type_data> = {kind : string; data : type_data;};
 
 
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		export function einpacken<typ_angaben>(art : string, angaben : typ_angaben) : typ_komplex<typ_angaben>
+		export function wrap<type_data>(kind : string, data : type_data) : type_complex<type_data>
 			{
-				return {"art": art, "angaben": angaben};
+				return {"kind": kind, "data": data};
 			}
 
 
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		export function auspacken<typ_angaben>(komplex : typ_komplex<typ_angaben>) : typ_angaben
+		export function unwrap<type_data>(complex : type_complex<type_data>) : type_data
 			{
-				return komplex.angaben;
+				return complex.data;
 			}
 
 
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		export function fallunterscheidung<typ_ergebnis>
+		export function distinguish<type_result>
 			(
-				komplex : typ_komplex<any>,
+				complex : type_complex<any>,
-				faelle : {[art : string] : (angaben ?: any)=>typ_ergebnis},
+				cases : {[kind : string] : (data ?: any)=>type_result},
-				ersatz : (komplex : typ_komplex<any>)=>typ_ergebnis = ((komplex) => {throw (new Error("unbehandelt"));})
+				fallback : (complex : type_complex<any>)=>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 function_ : (data ?: any)=>type_result = cases[complex.kind];
-						let ergebnis : typ_ergebnis = funktion(komplex.angaben);
+						let result : type_result = function_(complex.data);
-						return ergebnis;
+						return result;
 					}
 				else
 					{
-						let meldung : string = ("unbehandelte Art '" + komplex.art + "'");
+						let message : string = ("unbehandelte Art '" + complex.kind + "'");
-						console.warn(meldung);
+						console.warn(message);
-						let ergebnis : typ_ergebnis = ersatz(komplex);
+						let result : type_result = fallback(complex);
-						return ergebnis;
+						return result;
 					}
 			}
 	}

quelldatein/helfer/brauch.ts

@@ -17,22 +17,22 @@
  */
 
 
-module lib_brauch
+module lib_trait
 	{
 		
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		export type typ_brauch<typ_signatur> = {[domäne : string] : typ_signatur};
+		export type type_trait<type_signature> = {[domain : string] : type_signature};
 
 
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		export function erstellen<typ_signatur>
+		export function create<type_signature>
 			(
 			)
-			: typ_brauch<typ_signatur>
+			: type_trait<type_signature>
 			{
 				return {};
 			}
@@ -41,22 +41,22 @@ module lib_brauch
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		export function umsetzen<typ_signatur>
+		export function attend<type_signature>
 			(
-				brauch : typ_brauch<typ_signatur>,
+				trait : type_trait<type_signature>,
-				domaene : string,
+				domain : string,
-				implementierung : typ_signatur
+				implementation : type_signature
 			)
 			: void
 			{
-				if (domaene in brauch)
+				if (domain in trait)
 					{
-						let meldung : string = ("Domäne '" + domaene + "' bereits vorhanden");
+						let message : string = ("Domäne '" + domain + "' bereits vorhanden");
-						throw (new Error(meldung));
+						throw (new Error(message));
 					}
 				else
 					{
-						brauch[domaene] = implementierung;
+						trait[domain] = implementation;
 					}
 			}
 		
@@ -64,21 +64,21 @@ module lib_brauch
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		export function anwenden<typ_signatur>
+		export function deploy<type_signature>
 			(
-				brauch : typ_brauch<typ_signatur>,
+				trait : type_trait<type_signature>,
-				domaene : string
+				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");
+						let message : string = ("keine Implementierung für Domäne '" + domain + "' vorhanden");
-						throw (new Error(meldung));
+						throw (new Error(message));
 					}
 				else
 					{
-						return brauch[domaene];
+						return trait[domain];
 					}
 			}
 		

quelldatein/helfer/fehlermonade.ts

@@ -16,27 +16,27 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-module lib_fehlermonade
+module lib_errormonade
 	{
 		
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		export type typ_fehlermonade<typ_wert> = lib_aufruf.typ_komplex<any>;
+		export type type_errormonade<type_value> = lib_call.type_complex<any>;
 		
 		
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		export function erstellen_nichts<typ_wert>
+		export function create_nothing<type_value>
 			(
 			)
-			: typ_fehlermonade<typ_wert>
+			: type_errormonade<type_value>
 			{
 				return (
-					lib_aufruf.einpacken<any>
+					lib_call.wrap<any>
 						(
-							"nichts",
+							"nothing",
 							{
 							}
 						)
@@ -47,18 +47,18 @@ module lib_fehlermonade
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		export function erstellen_schlicht<typ_wert>
+		export function create_just<type_value>
 			(
-				wert : typ_wert
+				value : type_value
 			)
-			: typ_fehlermonade<typ_wert>
+			: type_errormonade<type_value>
 			{
 				return (
-					lib_aufruf.einpacken<any>
+					lib_call.wrap<any>
 						(
-							"schlicht",
+							"just",
 							{
-								"wert": wert
+								"value": value
 							}
 						)
 				);
@@ -68,19 +68,19 @@ module lib_fehlermonade
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		export function voll<typ_wert>
+		export function filled<type_value>
 			(
-				fehlermonade : typ_fehlermonade<typ_wert>
+				errormonade : type_errormonade<type_value>
 			)
 			: boolean
 			{
 				return (
-					lib_aufruf.fallunterscheidung<any>
+					lib_call.distinguish<any>
 						(
-							fehlermonade,
+							errormonade,
 							{
-								"nichts": ({}) => false,
+								"nothing": ({}) => false,
-								"schlicht": ({"wert": wert}) => true,
+								"just": ({"value": value}) => true,
 							}
 						)
 				);
@@ -90,19 +90,19 @@ module lib_fehlermonade
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		export function lesen<typ_wert>
+		export function read<type_value>
 			(
-				fehlermonade : typ_fehlermonade<typ_wert>
+				errormonade : type_errormonade<type_value>
 			)
-			: typ_wert
+			: type_value
 			{
 				return (
-					lib_aufruf.fallunterscheidung<any>
+					lib_call.distinguish<any>
 						(
-							fehlermonade,
+							errormonade,
 							{
-								"nichts": ({}) => {throw (new Error("lesen von nichts"));},
+								"nothing": ({}) => {throw (new Error("read von nothing"));},
-								"schlicht": ({"wert": wert}) => wert,
+								"just": ({"value": value}) => value,
 							}
 						)
 				);
@@ -112,20 +112,20 @@ module lib_fehlermonade
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		export function fortfuehren<typ_wert1, typ_wert2>
+		export function propagate<type_value1, type_value2>
 			(
-				fehlermonade : typ_fehlermonade<typ_wert1>,
+				errormonade : type_errormonade<type_value1>,
-				funktion : (wert1 : typ_wert1)=>typ_fehlermonade<typ_wert2>
+				funktion : (value1 : type_value1)=>type_errormonade<type_value2>
 			)
-			: typ_fehlermonade<typ_wert2>
+			: type_errormonade<type_value2>
 			{
 				return (
-					lib_aufruf.fallunterscheidung<any>
+					lib_call.distinguish<any>
 						(
-							fehlermonade,
+							errormonade,
 							{
-								"nichts": ({}) => erstellen_nichts<typ_wert2>(),
+								"nothing": ({}) => create_nothing<type_value2>(),
-								"schlicht": ({"wert": wert1}) => funktion(wert1),
+								"just": ({"value": value1}) => funktion(value1),
 							}
 						)
 				);

quelldatein/helfer/hashmap.ts

@@ -22,10 +22,10 @@ module lib_hashmap
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		export type typ_hashmap<typ_schluessel, typ_wert> =
+		export type type_hashmap<type_key, type_value> =
 			{
-				hashfunction : (schluessel : typ_schluessel)=>string;
+				hashfunction : (key : type_key)=>string;
-				speicher : {[hashwert : string] : {schluessel : typ_schluessel; wert : typ_wert;}};
+				store : {[hashvalue : string] : {key : type_key; value : type_value;}};
 			}
 		;
 		
@@ -33,15 +33,15 @@ module lib_hashmap
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		export function erstellen<typ_schluessel, typ_wert>
+		export function create<type_key, type_value>
 			(
-				hashfunction : (schluessel : typ_schluessel)=>string
+				hashfunction : (key : type_key)=>string
 			)
-			: typ_hashmap<typ_schluessel, typ_wert>
+			: type_hashmap<type_key, type_value>
 			{
 				return {
 					"hashfunction": hashfunction,
-					"speicher": {},
+					"store": {},
 				};
 			}
 		
@@ -49,38 +49,38 @@ module lib_hashmap
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		export function setzen<typ_schluessel, typ_wert>
+		export function set<type_key, type_value>
 			(
-				hashmap : typ_hashmap<typ_schluessel, typ_wert>,
+				hashmap : type_hashmap<type_key, type_value>,
-				schluessel : typ_schluessel,
+				key : type_key,
-				wert : typ_wert
+				value : type_value
 			)
 			: void
 			{
-				let hashwert : string = hashmap.hashfunction(schluessel);
+				let hashvalue : string = hashmap.hashfunction(key);
-				hashmap.speicher[hashwert] = {"schluessel": schluessel, "wert": wert};
+				hashmap.store[hashvalue] = {"key": key, "value": value};
 			}
 		
 		
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		export function holen<typ_schluessel, typ_wert>
+		export function get<type_key, type_value>
 			(
-				hashmap : typ_hashmap<typ_schluessel, typ_wert>,
+				hashmap : type_hashmap<type_key, type_value>,
-				schluessel : typ_schluessel
+				key : type_key
 			)
-			: lib_fehlermonade.typ_fehlermonade<typ_wert>
+			: lib_errormonade.type_errormonade<type_value>
 			{
-				let hashwert : string = hashmap.hashfunction(schluessel);
+				let hashvalue : string = hashmap.hashfunction(key);
-				if (hashwert in hashmap.speicher)
+				if (hashvalue in hashmap.store)
 					{
-						let wert : typ_wert = hashmap.speicher[hashwert].wert;
+						let value : type_value = hashmap.store[hashvalue].value;
-						return (lib_fehlermonade.erstellen_schlicht<typ_wert>(wert));
+						return (lib_errormonade.create_just<type_value>(value));
 					}
 				else
 					{
-						return (lib_fehlermonade.erstellen_nichts<typ_wert>());
+						return (lib_errormonade.create_nothing<type_value>());
 					}
 			}
 		
@@ -88,19 +88,19 @@ module lib_hashmap
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		export function iterieren<typ_schluessel, typ_wert>
+		export function iterate<type_key, type_value>
 			(
-				hashmap : typ_hashmap<typ_schluessel, typ_wert>,
+				hashmap : type_hashmap<type_key, type_value>,
-				prozedur : (schluessel ?: typ_schluessel, wert ?: typ_wert)=>void
+				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];
+								let paar : {key : type_key; value : type_value;} = hashmap.store[hashvalue];
-								prozedur(paar.schluessel, paar.wert);
+								procedure(paar.key, paar.value);
 							}
 					)
 				;

quelldatein/helfer/mathematik.ts

@@ -16,7 +16,7 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-module lib_mathematik
+module lib_math
 	{
 		
 		/**

quelldatein/helfer/uebersetzung.ts

@@ -17,46 +17,46 @@
  */
 
 
-module lib_uebersetzung
+module lib_translate
 	{
 		
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		var _sprachstapel : Array<string>;
+		var _languagestack : Array<string>;
 		
 		
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		var _daten : {[sprache : string] : {[schluessel : string] : string}} = {};
+		var _data : {[language : string] : {[key : string] : string}} = {};
 		
 		
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		export function einrichten(sprachen : Array<string>) : void
+		export function setup(languages : Array<string>) : void
 			{
-				_sprachstapel = [];
+				_languagestack = [];
-				sprachen.forEach
+				languages.forEach
 					(
-						sprache =>
+						language =>
 							{
-								let zeichenketten_roh_ : lib_fehlermonade.typ_fehlermonade<any> = mod_vtm.mod_daten.lesen("zeichenketten-" + sprache);
+								let strs_raw_ : lib_errormonade.type_errormonade<any> = mod_vtm.mod_data.read("strings-" + language);
-								if (lib_fehlermonade.voll(zeichenketten_roh_))
+								if (lib_errormonade.filled(strs_raw_))
 									{
-										let zeichenketten_roh : {[schluessel : string] : string} = (<{[schluessel : string] : string}>(lib_fehlermonade.lesen(zeichenketten_roh_)));
+										let strs_raw : {[key : string] : string} = (<{[key : string] : string}>(lib_errormonade.read(strs_raw_)));
-										_daten[sprache] = {};
+										_data[language] = {};
-										for (let schluessel in zeichenketten_roh)
+										for (let key in strs_raw)
 											{
-												_daten[sprache][schluessel] = (<string>(zeichenketten_roh[schluessel]));
+												_data[language][key] = (<string>(strs_raw[key]));
 											}
-										_sprachstapel.push(sprache);
+										_languagestack.push(language);
 									}
 								else
 									{
-										let meldung : string = ("Zeichenketten für Sprache '" + sprache + "' konnten nicht geladen werden");
+										let message : string = ("Zeichenketten für Sprache '" + language + "' konnten nicht geladen werden");
-										console.warn(meldung);
+										console.warn(message);
 									}
 							}
 					)
@@ -67,27 +67,27 @@ module lib_uebersetzung
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		function lesen(sprache : string, schluessel : string) : lib_fehlermonade.typ_fehlermonade<string>
+		function read(language : string, key : string) : lib_errormonade.type_errormonade<string>
 			{
-				if (sprache in _daten)
+				if (language in _data)
 					{
-						let satz : {[schluessel : string] : string} = _daten[sprache];
+						let dataset : {[key : string] : string} = _data[language];
-						if (schluessel in satz)
+						if (key in dataset)
 							{
-								return (lib_fehlermonade.erstellen_schlicht<string>(satz[schluessel]));
+								return (lib_errormonade.create_just<string>(dataset[key]));
 							}
 						else
 							{
-								let meldung : string = ("keine Zeichenketten für Schlüssel '" + schluessel + "' in Sprache '" + sprache + "'");
+								let message : string = ("keine Zeichenketten für Schlüssel '" + key + "' in Sprache '" + language + "'");
-								console.warn(meldung);
+								console.warn(message);
-								return (lib_fehlermonade.erstellen_nichts<string>());
+								return (lib_errormonade.create_nothing<string>());
 							}
 					}
 				else
 					{
-						let meldung : string = ("keine Zeichenketten für Sprache '" + sprache + "'");
+						let message : string = ("keine Zeichenketten für Sprache '" + language + "'");
-						console.warn(meldung);
+						console.warn(message);
-						return (lib_fehlermonade.erstellen_nichts<string>());
+						return (lib_errormonade.create_nothing<string>());
 					}
 			}
 		
@@ -95,19 +95,19 @@ module lib_uebersetzung
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		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<string> = (lib_fehlermonade.erstellen_nichts<string>());
+				let result : lib_errormonade.type_errormonade<string> = (lib_errormonade.create_nothing<string>());
-				let gefunden : boolean = (
+				let found : boolean = (
-					_sprachstapel
+					_languagestack
 					.some
 						(
-							sprache =>
+							language =>
 								{
-									let ergebnis_ : lib_fehlermonade.typ_fehlermonade<string> = lesen(sprache, schluessel);
+									let result_ : lib_errormonade.type_errormonade<string> = read(language, key);
-									if (lib_fehlermonade.voll(ergebnis_))
+									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 pattern : RegExp = (new RegExp("!var:" + name));
-								let wert : string = vars[name];
+								let value : string = vars[name];
-								str = str.replace(muster, wert);
+								str = str.replace(pattern, value);
 							}
 						return str;
 					}
 				else
 					{
-						return ("{" + schluessel + "}");
+						return ("{" + key + "}");
 					}
 			}
 		
@@ -138,31 +138,31 @@ module lib_uebersetzung
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		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 content : string = element.textContent;
-										let fund : any = muster.exec(inhalt);
+										let fund : any = pattern.exec(content);
 										if (fund != null)
 											{
-												let schluessel : string = fund[1];
+												let key : string = fund[1];
-												let inhalt_ : string = holen(schluessel);
+												let content_ : string = get(key);
-												element.textContent = inhalt_;
+												element.textContent = content_;
 											}
 										else
 											{
-												// nichts tun
+												// nothing tun
 											}
 									}
 								else
 									{
-										// nichts tun
+										// nothing tun
 									}
 							}
 					)

quelldatein/helfer/vektor.ts

@@ -16,39 +16,39 @@
  * along with this program.  If not, see <https://www.gnu.org/licenses/>.
  */
 
-module lib_vektor
+module lib_vector
 	{
 		
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		export type typ_vektor = {x : float; y : float;};
+		export type type_vector = {x : float; y : float;};
 		
 		
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		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 <vidofnir@folksprak.org>
 		 */
-		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 <vidofnir@folksprak.org>
 		 */
-		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)};
 			}
 		
 	}

quelldatein/helfer/verschiedenes.ts

@@ -25,16 +25,16 @@ module mod_vtm
 				/**
 				 * @author kcf <vidofnir@folksprak.org>
 				 */
-				export function sequenz(laenge : int) : Array<int>
+				export function sequence(laenge : int) : Array<int>
 					{
-						return ((laenge <= 0) ? [] : sequenz(laenge-1).concat([laenge-1]));
+						return ((laenge <= 0) ? [] : sequence(laenge-1).concat([laenge-1]));
 					}
 				
 				
 				/**
 				 * @author kcf <vidofnir@folksprak.org>
 				 */
-				export function liste_kopieren<type_element>(liste : Array<type_element>, element_kopieren : (element : type_element)=>type_element = (x => x)) : Array<type_element>
+				export function list_copy<type_element>(liste : Array<type_element>, element_kopieren : (element : type_element)=>type_element = (x => x)) : Array<type_element>
 					{
 						let liste_ : Array<type_element> = [];
 						liste.forEach

quelldatein/helfer/xml.ts

@@ -22,17 +22,17 @@ module lib_xml
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		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 <vidofnir@folksprak.org>
 		 */
-		export type typ_knoten = lib_aufruf.typ_komplex<any>;
+		export type type_node = lib_call.type_complex<any>;
 		
 		
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		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 <vidofnir@folksprak.org>
 		 */
-		export function erstellen_normal
+		export function create_normal
 			(
 				name : string,
-				attribute : {[schluessel : string] : string} = {},
+				attributes : {[key : string] : string} = {},
-				kinder : Array<typ_knoten> = []
+				children : Array<type_node> = []
 			)
-			: typ_knoten
+			: type_node
 			{
 				return (
-					lib_aufruf.einpacken
+					lib_call.wrap
 						(
 							"normal",
 							{
 								"name": name,
-								"attribute": attribute,
+								"attributes": attributes,
-								"kinder": kinder
+								"children": children
 							}
 						)
 				);
@@ -92,57 +92,57 @@ module lib_xml
 		/**
 		 * @author kcf <vidofnir@folksprak.org>
 		 */
-		export function darstellen
+		export function view
 			(
-				knoten : typ_knoten,
+				node : type_node,
-				tiefe : int = 0
+				depth : int = 0
 			)
 			: string
 			{
 				return (
-					lib_aufruf.fallunterscheidung<any>
+					lib_call.distinguish<any>
 						(
-							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 = "";
+											let str_begin : string = "";
-											str_anfang += name;
+											str_begin += name;
-											// attribute
+											// attributes
 											{
-												let str_attribute : string = "";
+												let str_attributes : string = "";
-												Object.keys(attribute).forEach
+												Object.keys(attributes).forEach
 													(
-														schluessel =>
+														key =>
 															{
-																let wert : string = attribute[schluessel];
+																let value : string = attributes[key];
-																str_attribute += (" " + schluessel + "=" + ("\"" +  wert + "\""));
+																str_attributes += (" " + key + "=" + ("\"" +  value + "\""));
 															}
 													)
 												;
-												str_anfang += str_attribute;
+												str_begin += str_attributes;
 											}
-											str_anfang = (einrueckung(tiefe) + "<" + str_anfang + ">" + "\n");
+											str_begin = (indent(depth) + "<" + str_begin + ">" + "\n");
-											str += str_anfang;
+											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 = "";
+											let str_end : string = "";
-											str_ende += name;
+											str_end += name;
-											str_ende = (einrueckung(tiefe) + "<" + "/" + str_ende + ">" + "\n");
+											str_end = (indent(depth) + "<" + "/" + str_end + ">" + "\n");
-											str += str_ende;
+											str += str_end;
 										}
 										return str;
 									}

quelldatein/manifestation/manifestation.ts

@@ -25,16 +25,16 @@ module mod_vtm
 				/**
 				 * @author kcf <vidofnir@folksprak.org>
 				 */
-				export type typ_manifestation<typ_aufbau> = lib_aufruf.typ_komplex<any>;
+				export type type_manifestation<type_model> = lib_call.type_complex<any>;
 				
 				
 				/**
 				 * @author kcf <vidofnir@folksprak.org>
 				 */
-				export type signatur_manifestation<typ_aufbau, typ_ausgabe> =
+				export type signature_manifestation<type_model, type_ausgabe> =
 					{
-						darstellen : (manifestation : typ_manifestation<typ_aufbau>)=>typ_ausgabe;
+						view : (manifestation : type_manifestation<type_model>)=>type_ausgabe;
-						binden : (manifestation : typ_manifestation<typ_aufbau>)=>void;
+						bind : (manifestation : type_manifestation<type_model>)=>void;
 					}
 				;
 				
@@ -42,46 +42,46 @@ module mod_vtm
 				/**
 				 * @author kcf <vidofnir@folksprak.org>
 				 */
-				export var brauch_manifestation : lib_brauch.typ_brauch<signatur_manifestation<any, any>> = lib_brauch.erstellen<signatur_manifestation<any, any>>();
+				export var trait_manifestation : lib_trait.type_trait<signature_manifestation<any, any>> = lib_trait.create<signature_manifestation<any, any>>();
 				
 				
 				/**
 				 * @author kcf <vidofnir@folksprak.org>
 				 */
-				export function darstellen<typ_aufbau, typ_ausgabe>
+				export function view<type_model, type_ausgabe>
 					(
-						manifestation : typ_manifestation<typ_aufbau>
+						manifestation : type_manifestation<type_model>
 					)
-					: 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 <vidofnir@folksprak.org>
 				 */
-				export function binden<typ_aufbau, typ_ausgabe>
+				export function bind<type_model, type_ausgabe>
 					(
-						manifestation : typ_manifestation<typ_aufbau>
+						manifestation : type_manifestation<type_model>
 					)
 					: void
 					{
-						return lib_brauch.anwenden(brauch_manifestation, manifestation.art)["binden"](manifestation);
+						return lib_trait.deploy(trait_manifestation, manifestation.kind)["bind"](manifestation);
 					}
 				
 				
 				/**
 				 * @author kcf <vidofnir@folksprak.org>
 				 */
-				export function einrichten<typ_aufbau, typ_ausgabe>
+				export function setup<type_model, type_ausgabe>
 					(
-						manifestation : typ_manifestation<typ_aufbau>
+						manifestation : type_manifestation<type_model>
 					)
 					: void
 					{
-						darstellen<typ_aufbau, typ_ausgabe>(manifestation);
+						view<type_model, type_ausgabe>(manifestation);
-						binden<typ_aufbau, typ_ausgabe>(manifestation);
+						bind<type_model, type_ausgabe>(manifestation);
 					}
 				
 			}

quelldatein/manifestation/position.ts

@@ -28,26 +28,26 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export type typ_position = lib_vektor.typ_vektor;
+						export type type_position = lib_vector.type_vector;
 						
 						
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						var basis1 : typ_position = lib_vektor.polar((0/6) * (2*Math.PI));
+						var basis1 : type_position = lib_vector.polar((0/6) * (2*Math.PI));
-						var basis2 : typ_position = lib_vektor.polar((2/6) * (2*Math.PI));
+						var basis2 : type_position = lib_vector.polar((2/6) * (2*Math.PI));
 						
 						
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						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_vector.scale(basis1, spot.u),
-											lib_vektor.skalieren(basis2, stelle.v)
+											lib_vector.scale(basis2, spot.v)
 										)
 								);
 							}

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 <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								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<mod_vtm.mod_aufbau.mod_partie.typ_partie>
+									: type_manifestation<mod_vtm.mod_model.mod_round.type_round>
 									{
 										return {
-											"art": "speicher_partie",
+											"kind": "store_round",
-											"angaben": erstellen(aufbau)
+											"data": create(model)
 										};
 									}
 								
@@ -72,7 +72,7 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								function darstellen(partie : typ_partie) : void
+								function view(round : type_round) : void
 									{
 									}
 								
@@ -80,68 +80,68 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								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,
+												round.model,
-												"aenderung_aufgabe",
+												"aendrung_task",
-												(angaben) =>
+												(data) =>
 													{
-														// console.info("aenderung_aufgabe", angaben);
+														// console.info("aendrung_task", data);
-														let aufgabe : mod_vtm.mod_aufbau.mod_aufgabe.typ_aufgabe = mod_vtm.mod_aufbau.mod_partie.aufgabe_lesen(partie.aufbau);
+														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_aufbau.mod_aufgabe.id(aufgabe);
+														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 world_ : any = JSON.parse(item);
-																let welt : mod_vtm.mod_aufbau.mod_welt.typ_welt = mod_vtm.mod_aufbau.mod_welt.importieren(welt_);
+																let world : mod_vtm.mod_model.mod_world.type_world = mod_vtm.mod_model.mod_world.import_(world_);
-																mod_vtm.mod_aufbau.mod_partie.welt_setzen(partie.aufbau, welt, false);
+																mod_vtm.mod_model.mod_round.world_set(round.model, world, false);
 															}
 														else
 															{
-																mod_vtm.mod_aufbau.mod_partie.welt_leeren(partie.aufbau);
+																mod_vtm.mod_model.mod_round.world_clear(round.model);
-																// nichts tun
+																// nothing tun
 															}
 													}
 											)
 										;
-										mod_vtm.mod_aufbau.mod_partie.lauschen
+										mod_vtm.mod_model.mod_round.lauschen
 											(
-												partie.aufbau,
+												round.model,
-												"aenderung_welt",
+												"aendrung_world",
-												(angaben) =>
+												(data) =>
 													{
-														let aufgabe : mod_vtm.mod_aufbau.mod_aufgabe.typ_aufgabe = mod_vtm.mod_aufbau.mod_partie.aufgabe_lesen(partie.aufbau);
+														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_aufbau.mod_aufgabe.id(aufgabe);
+														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 world : mod_vtm.mod_model.mod_world.type_world = mod_vtm.mod_model.mod_round.world_read(round.model);
-														let welt_ : any = mod_vtm.mod_aufbau.mod_welt.exportieren(welt);
+														let world_ : any = mod_vtm.mod_model.mod_world.export_(world);
-														let item : string = JSON.stringify(welt_);
+														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,
+												round.model,
-												"aenderung_figur",
+												"aendrung_token",
-												(angaben) =>
+												(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,
+												round.model,
-												"aenderung_modus",
+												"aendrung_mode",
-												(angaben) =>
+												(data) =>
 													{
-														// console.info("aenderung_modus", angaben);
+														// console.info("aendrung_mode", data);
 													}
 											)
 										;
@@ -151,13 +151,13 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								lib_brauch.umsetzen<signatur_manifestation<mod_vtm.mod_aufbau.mod_partie.typ_partie, void>>
+								lib_trait.attend<signature_manifestation<mod_vtm.mod_model.mod_round.type_round, void>>
 									(
-										brauch_manifestation,
+										trait_manifestation,
-										"speicher_partie",
+										"store_round",
 										{
-											"darstellen": (manifestation) => darstellen(manifestation.angaben),
+											"view": (manifestation) => view(manifestation.data),
-											"binden": (manifestation) => binden(manifestation.angaben),
+											"bind": (manifestation) => bind(manifestation.data),
 										}
 									)
 								;

quelldatein/manifestation/svg/_svg.ts

@@ -28,13 +28,13 @@ module mod_vtm
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						export const float_praezission : int = 4;
+						export const float_precision : int = 4;
 						
 						
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						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 <vidofnir@folksprak.org>
 						 */
-						export function pfad
+						export function path
 							(
-								vertices : Array<lib_vektor.typ_vektor>,
+								vertices : Array<lib_vector.type_vector>,
-								schliessen : boolean = true,
+								close : boolean = true,
-								attribute : {[schlussel : string] : string} = {},
+								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 x : string = vertex.x.toFixed(float_precision);
-												let y : string = vertex.y.toFixed(float_praezission);
+												let y : string = vertex.y.toFixed(float_precision);
 												d += [c, x, y].join(" ");
 											}
 									)
 								;
-								if (schliessen)
+								if (close)
 									d += "Z";
-								attribute["d"] = d;
+								attributes["d"] = d;
-								return (lib_xml.erstellen_normal("path", attribute));
+								return (lib_xml.create_normal("path", attributes));
 							}
 						
 						
 						/**
 						 * @author kcf <vidofnir@folksprak.org>
 						 */
-						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<lib_xml.typ_knoten> = []
+								children : Array<lib_xml.type_node> = []
 							)
-							: 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,
 										)
 								);
 							}

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 <vidofnir@folksprak.org>
 								 */
-								export type signatur_aktor =
+								export type signature_actuator =
 									{
-										darstellen : (aktor : mod_vtm.mod_aufbau.mod_aktor.typ_aktor)=>Array<lib_xml.typ_knoten>;
+										view : (actuator : mod_vtm.mod_model.mod_actuator.type_actuator)=>Array<lib_xml.type_node>;
 									}
 								;
 								
@@ -41,16 +41,16 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								export var brauch_aktor : lib_brauch.typ_brauch<signatur_aktor> = lib_brauch.erstellen<signatur_aktor>();
+								export var trait_actuator : lib_trait.type_trait<signature_actuator> = lib_trait.create<signature_actuator>();
 								
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								export type typ_aktor =
+								export type type_actuator =
 									{
-										aufbau : mod_vtm.mod_aufbau.mod_aktor.typ_aktor;
+										model : mod_vtm.mod_model.mod_actuator.type_actuator;
-										stelle : mod_vtm.mod_aufbau.mod_stelle.typ_stelle;
+										spot : mod_vtm.mod_model.mod_spot.type_spot;
 									}
 								;
 								
@@ -58,16 +58,16 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								function erstellen
+								function create
 									(
-										aufbau : mod_vtm.mod_aufbau.mod_aktor.typ_aktor,
+										model : mod_vtm.mod_model.mod_actuator.type_actuator,
-										stelle : mod_vtm.mod_aufbau.mod_stelle.typ_stelle
+										spot : mod_vtm.mod_model.mod_spot.type_spot
 									)
-									: typ_aktor
+									: type_actuator
 									{
 										return {
-											"aufbau": aufbau,
+											"model": model,
-											"stelle": stelle
+											"spot": spot
 										};
 									}
 								
@@ -75,16 +75,16 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								export function erstellen_manifestation
+								export function create_manifestation
 									(
-										aufbau : mod_vtm.mod_aufbau.mod_aktor.typ_aktor,
+										model : mod_vtm.mod_model.mod_actuator.type_actuator,
-										stelle : mod_vtm.mod_aufbau.mod_stelle.typ_stelle
+										spot : mod_vtm.mod_model.mod_spot.type_spot
 									)
-									: typ_manifestation<mod_vtm.mod_aufbau.mod_aktor.typ_aktor>
+									: type_manifestation<mod_vtm.mod_model.mod_actuator.type_actuator>
 									{
 										return {
-											"art": "svg_aktor",
+											"kind": "svg_actuator",
-											"angaben": erstellen(aufbau, stelle),
+											"data": create(model, spot),
 										};
 									}
 								
@@ -92,15 +92,15 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								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 actuator : mod_vtm.mod_model.mod_actuator.type_actuator = actuator_.model;
-										let knoten_rahmen = function () : lib_xml.typ_knoten
+										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 position : mod_position.type_position = mod_position.von_spot(actuator_.spot);
-										let knoten_feld : lib_xml.typ_knoten = (
+										let node_tile : lib_xml.type_node = (
-											lib_xml.erstellen_normal
+											lib_xml.create_normal
 												(
 													"g",
 													{
-														"class": "feld",
+														"class": "tile",
-														"rel": mod_vtm.mod_aufbau.mod_stelle.hash(aktor_.stelle),
+														"rel": mod_vtm.mod_model.mod_spot.hash(actuator_.spot),
 														"transform": translation(position.x, position.y),
 													},
 													(
-														[knoten_rahmen()]
+														[node_rahmen()]
-														.concat(lib_brauch.anwenden<signatur_aktor>(brauch_aktor, aktor.art)["darstellen"](aktor))
+														.concat(lib_trait.deploy<signature_actuator>(trait_actuator, actuator.kind)["view"](actuator))
 													)
 												)
 										);
-										return knoten_feld;
+										return node_tile;
 									}
 								
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								function binden(aktor : typ_aktor) : void
+								function bind(actuator : type_actuator) : void
 									{
 									}
 									
@@ -140,13 +140,13 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								lib_brauch.umsetzen<signatur_manifestation<mod_vtm.mod_aufbau.mod_aktor.typ_aktor, lib_xml.typ_knoten>>
+								lib_trait.attend<signature_manifestation<mod_vtm.mod_model.mod_actuator.type_actuator, lib_xml.type_node>>
 									(
-										brauch_manifestation,
+										trait_manifestation,
-										"svg_aktor",
+										"svg_actuator",
 										{
-											"darstellen": (manifestation) => darstellen(manifestation.angaben),
+											"view": (manifestation) => view(manifestation.data),
-											"binden": (manifestation) => binden(manifestation.angaben),
+											"bind": (manifestation) => bind(manifestation.data),
 										}
 									)
 								;

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 <vidofnir@folksprak.org>
 								 */
-								lib_brauch.umsetzen
+								lib_trait.attend
 									(
-										brauch_aktor,
+										trait_actuator,
 										"annehmer",
 										{
-											"darstellen": (aktor) =>
+											"view": (actuator) =>
 												{
-													let kinder : Array<lib_xml.typ_knoten> = [];
+													let children : Array<lib_xml.type_node> = [];
-													let knoten_kreis : lib_xml.typ_knoten = (
+													let node_kreis : lib_xml.type_node = (
-														lib_xml.erstellen_normal
+														lib_xml.create_normal
 															(
 																"circle",
 																{
-																	"cx": (0.0).toFixed(float_praezission),
+																	"cx": (0.0).toFixed(float_precision),
-																	"cy": (0.0).toFixed(float_praezission),
+																	"cy": (0.0).toFixed(float_precision),
-																	"r": (0.25).toFixed(float_praezission),
+																	"r": (0.25).toFixed(float_precision),
 																	"class": (
 																		[
 																			"kreis",
@@ -56,8 +56,8 @@ module mod_vtm
 																}
 															)
 													);
-													kinder.push(knoten_kreis);
+													children.push(node_kreis);
-													return kinder;
+													return children;
 												}
 											,
 										}

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 <vidofnir@folksprak.org>
 								 */
-								lib_brauch.umsetzen
+								lib_trait.attend
 									(
-										brauch_aktor,
+										trait_actuator,
 										"befoerderer",
 										{
-											"darstellen": ({"angaben": {"richtung": richtung}}) =>
+											"view": ({"data": {"direction": direction}}) =>
 												{
-													let kinder : Array<lib_xml.typ_knoten> = [];
+													let children : Array<lib_xml.type_node> = [];
-													let knoten_pfeil : lib_xml.typ_knoten = (
+													let node_pfeil : lib_xml.type_node = (
-														lib_xml.erstellen_normal
+														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);
+													children.push(node_pfeil);
-													return kinder;
+													return children;
 												}
 											,
 										}

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 <vidofnir@folksprak.org>
 								 */
-								lib_brauch.umsetzen
+								lib_trait.attend
 									(
-										brauch_aktor,
+										trait_actuator,
 										"erzeuger",
 										{
-											"darstellen": ({"angaben": {"richtung": richtung}}) =>
+											"view": ({"data": {"direction": direction}}) =>
 												{
-													let kinder : Array<lib_xml.typ_knoten> = [];
+													let children : Array<lib_xml.type_node> = [];
-													let knoten_pfeil : lib_xml.typ_knoten = (
+													let node_pfeil : lib_xml.type_node = (
-														lib_xml.erstellen_normal
+														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);
+													children.push(node_pfeil);
-													return kinder;
+													return children;
 												}
 											,
 										}

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 <vidofnir@folksprak.org>
 								 */
-								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<lib_xml.typ_knoten> = [];
+													let children : Array<lib_xml.type_node> = [];
-													type typ_eintrag =
+													type type_eintrag =
 														{
-															summand : mod_vtm.mod_aufbau.mod_richtung.typ_richtung;
+															summand : mod_vtm.mod_model.mod_direction.type_direction;
-															symbol : lib_fehlermonade.typ_fehlermonade<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>;
+															symbol : lib_errormonade.type_errormonade<mod_vtm.mod_model.mod_symbol.type_symbol>;
 														}
 													;
-													let ausgaenge : Array<typ_eintrag> =
+													let ausgaenge : Array<type_eintrag> =
 														[
 															{
 																"summand": 0,
-																"symbol": lib_fehlermonade.erstellen_nichts<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>(),
+																"symbol": lib_errormonade.create_nothing<mod_vtm.mod_model.mod_symbol.type_symbol>(),
 															},
 															{
 																"summand": +2,
-																"symbol": lib_fehlermonade.erstellen_schlicht<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>(symbol_links),
+																"symbol": lib_errormonade.create_just<mod_vtm.mod_model.mod_symbol.type_symbol>(symbol_links),
 															},
 															{
 																"summand": -2,
-																"symbol": lib_fehlermonade.erstellen_schlicht<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>(symbol_rechts),
+																"symbol": lib_errormonade.create_just<mod_vtm.mod_model.mod_symbol.type_symbol>(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 anglestaerke : float = (mod_vtm.mod_model.mod_direction.add(direction, eintrag.summand) / 6);
-																	let knoten_pfeil : lib_xml.typ_knoten = (
+																	let node_pfeil : lib_xml.type_node = (
-																		lib_xml.erstellen_normal
+																		lib_xml.create_normal
 																			(
 																				"path",
 																				{
-																					"d": form_pfeil,
+																					"d": shape_arrow,
 																					"class": (
 																						[
 																							"pfeil",
 																							(
-																								lib_fehlermonade.voll<mod_aufbau.mod_symbol.typ_symbol>(eintrag.symbol)
+																								lib_errormonade.filled<mod_model.mod_symbol.type_symbol>(eintrag.symbol)
-																								? "symbol_" + lib_fehlermonade.lesen<mod_aufbau.mod_symbol.typ_symbol>(eintrag.symbol).toFixed(0)
+																								? "symbol_" + lib_errormonade.read<mod_model.mod_symbol.type_symbol>(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;
 												}
 											,
 										}

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 <vidofnir@folksprak.org>
 								 */
-								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<lib_xml.typ_knoten> = [];
+													let children : Array<lib_xml.type_node> = [];
-													let knoten_pfeil : lib_xml.typ_knoten = (
+													let node_pfeil : lib_xml.type_node = (
-														lib_xml.erstellen_normal
+														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);
+													children.push(node_pfeil);
-													return kinder;
+													return children;
 												}
 											,
 										}

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 <vidofnir@folksprak.org>
 								 */
-								lib_brauch.umsetzen
+								lib_trait.attend
 									(
-										brauch_aktor,
+										trait_actuator,
 										"verwerfer",
 										{
-											"darstellen": (aktor) =>
+											"view": (actuator) =>
 												{
-													let kinder : Array<lib_xml.typ_knoten> = [];
+													let children : Array<lib_xml.type_node> = [];
-													let knoten_kreis : lib_xml.typ_knoten = (
+													let node_kreis : lib_xml.type_node = (
-														lib_xml.erstellen_normal
+														lib_xml.create_normal
 															(
 																"circle",
 																{
-																	"cx": (0.0).toFixed(float_praezission),
+																	"cx": (0.0).toFixed(float_precision),
-																	"cy": (0.0).toFixed(float_praezission),
+																	"cy": (0.0).toFixed(float_precision),
-																	"r": (0.25).toFixed(float_praezission),
+																	"r": (0.25).toFixed(float_precision),
 																	"class": (
 																		[
 																			"kreis",
@@ -56,8 +56,8 @@ module mod_vtm
 																}
 															)
 													);
-													kinder.push(knoten_kreis);
+													children.push(node_kreis);
-													return kinder;
+													return children;
 												}
 											,
 										}

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 <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								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<mod_vtm.mod_aufbau.mod_figur.typ_figur>
+									: type_manifestation<mod_vtm.mod_model.mod_token.type_token>
 									{
 										return {
-											"art": "svg_figur",
+											"kind": "svg_token",
-											"angaben": erstellen(aufbau),
+											"data": create(model),
 										};
 									}
 								
@@ -72,54 +72,54 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								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 token : mod_vtm.mod_model.mod_token.type_token = token_.model;
-										let kinder_figur : Array<lib_xml.typ_knoten> = [];
+										let children_token : Array<lib_xml.type_node> = [];
 										// Stein
 										{
-											let knoten_stein : lib_xml.typ_knoten = (
+											let node_stein : lib_xml.type_node = (
-												lib_xml.erstellen_normal
+												lib_xml.create_normal
 													(
 														"circle",
 														{
-															"cx": (0.0).toFixed(float_praezission),
+															"cx": (0.0).toFixed(float_precision),
-															"cy": (0.0).toFixed(float_praezission),
+															"cy": (0.0).toFixed(float_precision),
-															"r": (0.125).toFixed(float_praezission),
+															"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_symbol.typ_symbol> = mod_vtm.mod_aufbau.mod_figur.band_lesen(figur);
+											let tape : Array<mod_vtm.mod_model.mod_symbol.type_symbol> = mod_vtm.mod_model.mod_token.tape_read(token);
-											let kinder_band : Array<lib_xml.typ_knoten> = [];
+											let children_tape : Array<lib_xml.type_node> = [];
-											band.forEach
+											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 = (
+															let node_eintrag : lib_xml.type_node = (
-																lib_xml.erstellen_normal
+																lib_xml.create_normal
 																	(
 																		"circle",
 																		{
-																			"cx": x.toFixed(float_praezission),
+																			"cx": x.toFixed(float_precision),
-																			"cy": y.toFixed(float_praezission),
+																			"cy": y.toFixed(float_precision),
-																			"r": r.toFixed(float_praezission),
+																			"r": r.toFixed(float_precision),
 																			/*
-																			"x": (x-r).toFixed(float_praezission),
+																			"x": (x-r).toFixed(float_precision),
-																			"y": (y-r).toFixed(float_praezission),
+																			"y": (y-r).toFixed(float_precision),
-																			"width": (2*r).toFixed(float_praezission),
+																			"width": (2*r).toFixed(float_precision),
-																			"height": (2*r).toFixed(float_praezission),
+																			"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 = (
+											let node_tape = (
-												lib_xml.erstellen_normal
+												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 position : mod_position.type_position = mod_position.von_spot(mod_vtm.mod_model.mod_token.spot_read(token));
-										let knoten_figur = (
+										let node_token = (
-											lib_xml.erstellen_normal
+											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 <vidofnir@folksprak.org>
 								 */
-								function binden(figur : typ_figur) : void
+								function bind(token : type_token) : void
 									{
 									}
 								
@@ -173,13 +173,13 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								lib_brauch.umsetzen<signatur_manifestation<mod_vtm.mod_aufbau.mod_figur.typ_figur, lib_xml.typ_knoten>>
+								lib_trait.attend<signature_manifestation<mod_vtm.mod_model.mod_token.type_token, lib_xml.type_node>>
 									(
-										brauch_manifestation,
+										trait_manifestation,
-										"svg_figur",
+										"svg_token",
 										{
-											"darstellen": (manifestation) => darstellen(manifestation.angaben),
+											"view": (manifestation) => view(manifestation.data),
-											"binden": (manifestation) => binden(manifestation.angaben),
+											"bind": (manifestation) => bind(manifestation.data),
 										}
 									)
 								;

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 <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								export function erstellen_manifestation(aufbau : mod_vtm.mod_aufbau.mod_partie.typ_partie) : typ_manifestation<mod_vtm.mod_aufbau.mod_partie.typ_partie>
+								export function create_manifestation(model : mod_vtm.mod_model.mod_round.type_round) : type_manifestation<mod_vtm.mod_model.mod_round.type_round>
 									{
 										return {
-											"art": "svg_partie",
+											"kind": "svg_round",
-											"angaben": erstellen(aufbau)
+											"data": create(model)
 										};
 									}
 								
@@ -64,83 +64,83 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								function darstellen(partie : typ_partie) : lib_xml.typ_knoten
+								function view(round : type_round) : lib_xml.type_node
 									{
-										let kinder_partie : Array<lib_xml.typ_knoten> = [];
+										let children_round : Array<lib_xml.type_node> = [];
 										// Welt
 										{
-											let kinder_welt : Array<lib_xml.typ_knoten> = [];
+											let children_world : Array<lib_xml.type_node> = [];
 											// Felder
 											{
-												let kinder_felder : Array<lib_xml.typ_knoten> = [];
+												let children_tiles : Array<lib_xml.type_node> = [];
-												mod_vtm.mod_aufbau.mod_welt.felder_lesen(mod_vtm.mod_aufbau.mod_partie.welt_lesen(partie.aufbau)).forEach
+												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_vtm.mod_aufbau.mod_aktor.typ_aktor> = mod_aktor.erstellen_manifestation(aktor, stelle);
+																let manifestation_tile : type_manifestation<mod_vtm.mod_model.mod_actuator.type_actuator> = mod_actuator.create_manifestation(actuator, spot);
-																let knoten_feld : lib_xml.typ_knoten = mod_manifestation.darstellen(manifestation_feld);
+																let node_tile : lib_xml.type_node = mod_manifestation.view(manifestation_tile);
-																kinder_felder.push(knoten_feld);
+																children_tiles.push(node_tile);
 															}
 													)
 												;
-												let knoten_felder : lib_xml.typ_knoten = (
+												let node_tiles : lib_xml.type_node = (
-													lib_xml.erstellen_normal
+													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 = (
+											let node_world : lib_xml.type_node = (
-												lib_xml.erstellen_normal
+												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_figur.typ_figur> = mod_vtm.mod_aufbau.mod_partie.figur_lesen(partie.aufbau);
+											let token_ : lib_errormonade.type_errormonade<mod_vtm.mod_model.mod_token.type_token> = mod_vtm.mod_model.mod_round.token_read(round.model);
-											if (lib_fehlermonade.voll(figur_))
+											if (lib_errormonade.filled(token_))
 												{
-													let figur : mod_vtm.mod_aufbau.mod_figur.typ_figur = lib_fehlermonade.lesen(figur_);
+													let token : mod_vtm.mod_model.mod_token.type_token = lib_errormonade.read(token_);
-													let manifestation_figur : typ_manifestation<mod_vtm.mod_aufbau.mod_figur.typ_figur> = mod_figur.erstellen_manifestation(figur);
+													let manifestation_token : type_manifestation<mod_vtm.mod_model.mod_token.type_token> = mod_token.create_manifestation(token);
-													let knoten_figur : lib_xml.typ_knoten = mod_manifestation.darstellen(manifestation_figur);
+													let node_token : lib_xml.type_node = mod_manifestation.view(manifestation_token);
-													kinder_partie.push(knoten_figur);
+													children_round.push(node_token);
 												}
 											else
 												{
-													// nichts tun
+													// nothing tun
 												}
 										}
-										let knoten_partie : lib_xml.typ_knoten = (
+										let node_round : lib_xml.type_node = (
-											lib_xml.erstellen_normal
+											lib_xml.create_normal
 												(
 													"g",
 													{
-														"class": "partie",
+														"class": "round",
 													},
-													kinder_partie
+													children_round
 												)
 										);
-										return knoten_partie;
+										return node_round;
 									}
 								
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								function binden(partie : typ_partie) : void
+								function bind(round : type_round) : void
 									{
 									}
 								
@@ -148,13 +148,13 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								lib_brauch.umsetzen<signatur_manifestation<mod_vtm.mod_aufbau.mod_partie.typ_partie, lib_xml.typ_knoten>>
+								lib_trait.attend<signature_manifestation<mod_vtm.mod_model.mod_round.type_round, lib_xml.type_node>>
 									(
-										brauch_manifestation,
+										trait_manifestation,
-										"svg_partie",
+										"svg_round",
 										{
-											"darstellen": (manifestation) => darstellen(manifestation.angaben),
+											"view": (manifestation) => view(manifestation.data),
-											"binden": (manifestation) => binden(manifestation.angaben),
+											"bind": (manifestation) => bind(manifestation.data),
 										}
 									)
 								;

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 <vidofnir@folksprak.org>
 								 */
-								function text_nachbearbeiten(text : string) : string
+								function text_nachedit(text : string) : string
 									{
 										let regexp : RegExp = (new RegExp("\\$\{s(\\d*)\}", "g"));
 										return text.replace(regexp, "<span class=\"symbol_$1\">&nbsp;&nbsp;</span>");
@@ -41,11 +41,11 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								export type typ_partie =
+								export type type_round =
 									{
-										aufbau : mod_aufbau.mod_partie.typ_partie;
+										model : mod_model.mod_round.type_round;
-										bereich : Element;
+										area : Element;
-										intervall : lib_fehlermonade.typ_fehlermonade<any>;
+										intervall : lib_errormonade.type_errormonade<any>;
 									}
 								;
 								
@@ -53,17 +53,17 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								function erstellen
+								function create
 									(
-										aufbau : mod_aufbau.mod_partie.typ_partie,
+										model : mod_model.mod_round.type_round,
-										bereich : Element
+										area : Element
 									)
-									: typ_partie
+									: type_round
 									{
 										return {
-											"aufbau": aufbau,
+											"model": model,
-											"bereich": bereich,
+											"area": area,
-											"intervall": (lib_fehlermonade.erstellen_nichts<any>()),
+											"intervall": (lib_errormonade.create_nothing<any>()),
 										};
 									}
 								
@@ -71,16 +71,16 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								export function erstellen_erweitert
+								export function create_erweitert
 									(
-										aufbau : mod_aufbau.mod_partie.typ_partie,
+										model : mod_model.mod_round.type_round,
-										bereich : Element
+										area : Element
 									)
-									: typ_manifestation<mod_aufbau.mod_partie.typ_partie>
+									: type_manifestation<mod_model.mod_round.type_round>
 									{
 										return {
-											"art": "web_partie",
+											"kind": "web_round",
-											"angaben": erstellen(aufbau, bereich)
+											"data": create(model, area)
 										};
 									}
 								
@@ -88,14 +88,14 @@ module mod_vtm
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								function erneuern_aufgabe(partie : typ_partie) : void
+								function update_task(round : type_round) : void
 									{
-										document.querySelector("#aufgabe_text").innerHTML = (
+										document.querySelector("#task_text").innerHTML = (
-											text_nachbearbeiten
+											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 <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								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 <vidofnir@folksprak.org>
 								 */
-								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";
+														let message : string = "unbehandelter Modus";
-														throw (new Error(meldung));
+														throw (new Error(message));
 														break;
 													}
 											}
-										document.querySelector("#aufgabe_status").textContent = status;
+										document.querySelector("#task_status").textContent = status;
 									}
 								
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								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<any>(partie.intervall)
+															lib_errormonade.filled<any>(round.intervall)
-															? "ungewiss_laufend"
+															? "uncertain_running"
-															: "ungewiss_stehend"
+															: "uncertain_standing"
 														);
 														break;
 													}
-												case mod_vtm.mod_aufbau.mod_modus.fehlerhaft:
+												case mod_vtm.mod_model.mod_mode.wrong:
-												case mod_vtm.mod_aufbau.mod_modus.korrekt:
+												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 <vidofnir@folksprak.org>
 								 */
-								function darstellen(partie : typ_partie) : void
+								function view(round : type_round) : void
 									{
-										erneuern_aufgabe(partie);
+										update_task(round);
-										erneuern_welt(partie);
+										update_world(round);
-										erneuern_figur(partie);
+										update_token(round);
-										erneuern_modus(partie);
+										update_mode(round);
-										erneuern_knoepfe(partie);
+										update_buttons(round);
 									}
 								
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								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));
+												clearInterval(lib_errormonade.read(round.intervall));
-												partie.intervall = (lib_fehlermonade.erstellen_nichts<any>());
+												round.intervall = (lib_errormonade.create_nothing<any>());
 											}
 										else
 											{
-												let meldung : string = "kein Intervall gesetzt";
+												let message : string = "kein Intervall gesetzt";
-												console.warn(meldung);
+												console.warn(message);
 											}
-										erneuern_knoepfe(partie);
+										update_buttons(round);
 									}
 								
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								function fortfahren(partie : typ_partie) : void
+								function resume(round : type_round) : void
 									{
-										mod_vtm.mod_aufbau.mod_partie.fortfahren(partie.aufbau);
+										mod_vtm.mod_model.mod_round.resume(round.model);
-										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);
-										if (modus <= 1)
+										if (mode <= 1)
 											{
-												// nichts tun
+												// nothing tun
 											}
 										else
 											{
-												anhalten(partie);
+												stop(round);
 											}
-										erneuern_knoepfe(partie);
+										update_buttons(round);
 									}
 								
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								function testen(partie : typ_partie) : void
+								function testen(round : type_round) : void
 									{
-										let handle : any = setInterval(() => fortfahren(partie), 500);
+										let handle : any = setInterval(() => resume(round), 500);
-										partie.intervall = (lib_fehlermonade.erstellen_schlicht<any>(handle));
+										round.intervall = (lib_errormonade.create_just<any>(handle));
 									}
 								
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								function bearbeiten(partie : typ_partie) : void
+								function edit(round : type_round) : void
 									{
-										anhalten(partie);
+										stop(round);
-										mod_vtm.mod_aufbau.mod_partie.zuruecksetzen(partie.aufbau);
+										mod_vtm.mod_model.mod_round.reset(round.model);
 									}
 								
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								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_model.mod_round.world_clear(round.model);
-										mod_vtm.mod_aufbau.mod_partie.zuruecksetzen(partie.aufbau);
+										mod_vtm.mod_model.mod_round.reset(round.model);
 									}
 								
 								
 								/**
 								 * @author kcf <vidofnir@folksprak.org>
 								 */
-								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<mod_vtm.mod_aufbau.mod_stelle.typ_stelle>;
+												let spot : lib_errormonade.type_errormonade<mod_vtm.mod_model.mod_spot.type_spot>;
-												let dom_feld : Element = target["closest"](".feld");
+												let dom_tile : Element = target["closest"](".tile");
-												if (dom_feld == null)
+												if (dom_tile == null)
 													{
-														stelle = (lib_fehlermonade.erstellen_nichts<mod_vtm.mod_aufbau.mod_stelle.typ_stelle>());
+														spot = (lib_errormonade.create_nothing<mod_vtm.mod_model.mod_spot.type_spot>());
 													}
 												else
 													{
-														let rel : string = dom_feld.getAttribute("rel")
+														let rel : string = dom_tile.getAttribute("rel")
-														stelle = (lib_fehlermonade.erstellen_schlicht<mod_vtm.mod_aufbau.mod_stelle.typ_stelle>(mod_vtm.mod_aufbau.mod_stelle.von_hash(rel)));
+														spot = (lib_errormonade.create_just<mod_vtm.mod_model.mod_spot.type_spot>(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,
+												round.model,
-												"aenderung_aufgabe",
+												"aendrung_task",
-												(angaben) =>
+												(data) =>
 													{
-														erneuern_aufgabe(partie);
+														update_task(round);
 													}
 											)
 										;
-										mod_vtm.mod_aufbau.mod_partie.lauschen
+										mod_vtm.mod_model.mod_round.lauschen
 											(
-												partie.aufbau,
+												round.model,
-												"aenderung_welt",
+												"aendrung_world",
-												(angaben) =>
+												(data) =>
 													{
-														erneuern_welt(partie);
+														update_world(round);
 													}
 											)
 										;
-										mod_vtm.mod_aufbau.mod_partie.lauschen
+										mod_vtm.mod_model.mod_round.lauschen
 											(
-												partie.aufbau,
+												round.model,
-												"aenderung_figur",
+												"aendrung_token",
-												(angaben) =>
+												(data) =>
 													{
-														erneuern_figur(partie);
+														update_token(round);
 													}
 											)
 										;
-										mod_vtm.mod_aufbau.mod_partie.lauschen
+										mod_vtm.mod_model.mod_round.lauschen
 											(
-												partie.aufbau,
+												round.model,
-												"aenderung_modus",
+												"aendrung_mode",
-												(angaben) =>
+												(data) =>
 													{
-														erneuern_modus(partie);
+														update_mode(round);
-														erneuern_knoepfe(partie);
+														update_buttons(round);
 													}
 											)
 										;
 										// Links-Klick
-										partie.bereich.addEventListener
+										round.area.addEventListener
 											(
 												"click",
 												event =>
 													{
 														event.preventDefault();
-														let stelle_ : lib_fehlermonade.typ_fehlermonade<mod_vtm.mod_aufbau.mod_stelle.typ_stelle> = stelle_ermitteln(event.target);
+														let spot_ : lib_errormonade.type_errormonade<mod_vtm.mod_model.mod_spot.type_spot> = spot_ermitteln(event.target);
-														if (lib_fehlermonade.voll(stelle_))
+														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<mod_vtm.mod_aufbau.mod_stelle.typ_stelle> = stelle_ermitteln(event.target);
+														let spot_ : lib_errormonade.type_errormonade<mod_vtm.mod_model.mod_spot.type_spot> = spot_ermitteln(event.target);
-														if (lib_fehlermonade.voll(stelle_))
+														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<mod_vtm.mod_aufbau.mod_stelle.typ_stelle> = stelle_ermitteln(event.target);
+														let spot_ : lib_errormonade.type_errormonade<mod_vtm.mod_model.mod_spot.type_spot> = spot_ermitteln(event.target);
-														if (lib_fehlermonade.voll(stelle_))
+														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);
+														stop(round);
-														fortfahren(partie);
+														resume(round);
 													}
 											)
 										;
 										// Testen
-										document.querySelector("#knopf_testen").addEventListener
+										document.querySelector("#button_test").addEventListener
 											(
 												"click",
 												event =>
 													{
-														testen(partie);
+														testen(round);
 													}
 											)
 										;
-										// Anhalten
+										// stop
-										document.querySelector("#knopf_anhalten").addEventListener
+										document.querySelector("#button_stop").addEventListener
 											(
 												"click",
 												event =>
 													{
-														anhalten(partie);
+														stop(round);
 													}
 											)
 										;
-										// Bearbeiten
+										// edit
-										document.querySelector("#knopf_bearbeiten").addEventListener
+										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 <vidofnir@folksprak.org>
 								 */
-								lib_brauch.umsetzen<signatur_manifestation<mod_vtm.mod_aufbau.mod_partie.typ_partie, void>>
+								lib_trait.attend<signature_manifestation<mod_vtm.mod_model.mod_round.type_round, void>>
 									(
-										brauch_manifestation,
+										trait_manifestation,
-										"web_partie",
+										"web_round",
 										{
-											"darstellen": (manifestation) => darstellen(manifestation.angaben),
+											"view": (manifestation) => view(manifestation.data),
-											"binden": (manifestation) => binden(manifestation.angaben),
+											"bind": (manifestation) => bind(manifestation.data),
 										}
 									)
 								;

quelldatein/manifestation/web/vtm.html

@@ -4,99 +4,99 @@
 		<meta charset="utf-8"/>
 		<script type="text/javascript" src="vtm.js"></script>
 		<script type="text/javascript" src="vtm.dat.js"></script>
-		<script type="text/javascript">mod_vtm.eingang_web();</script>
+		<script type="text/javascript">mod_vtm.entry_web();</script>
 		<link rel="stylesheet" type="text/css" href="vtm.css"/>
 	</head>
 	<body>
-		<header>!translate:allgemein.titel</header>
+		<header>!translate:common.title</header>
-		<label for="radio_hilfe"><a>!translate:allgemein.hilfe</a></label><input type="radio" name="tab" id="radio_hilfe" checked="checked"/>
+		<label for="radio_help"><a>!translate:common.help</a></label><input type="radio" name="tab" id="radio_help" checked="checked"/>
-		<label for="radio_spiel"><a>!translate:allgemein.spiel</a></label><input type="radio" name="tab" id="radio_spiel"/>
+		<label for="radio_game"><a>!translate:common.game</a></label><input type="radio" name="tab" id="radio_game"/>
 		<!--
 		<hr/>
 		  -->
-		<div id="spiel">
+		<div id="game">
-			<div class="bereich" id="bereich_links">
+			<div class="section" id="section_left">
-				<label for="aufgabe_auswahl">!translate:steuerung.auswaehlen</label>
+				<label for="task_selection">!translate:controls.choose</label>
-				<select id="aufgabe_auswahl"></select>
+				<select id="task_selection"></select>
-				<p id="aufgabe_text"></p>
+				<p id="task_text"></p>
 				<hr/>
-				<div id="aufgabe_status"></div>
+				<div id="task_status"></div>
-				<div id="knoepfe">
+				<div id="buttons">
-					<button id="knopf_schritt">!translate:steuerung.schritt</button>
+					<button id="button_step">!translate:controls.step</button>
-					<button id="knopf_testen">!translate:steuerung.test</button>
+					<button id="button_test">!translate:controls.run</button>
-					<button id="knopf_anhalten">!translate:steuerung.anhalten</button>
+					<button id="button_stop">!translate:controls.stop</button>
-					<button id="knopf_bearbeiten">!translate:steuerung.bearbeiten</button>
+					<button id="button_edit">!translate:controls.edit</button>
-					<button id="knopf_leeren">!translate:steuerung.leeren</button>
+					<button id="button_clear">!translate:controls.clear</button>
 				</div>
 			</div>
-			<div class="bereich" id="bereich_mitte">
+			<div class="section" id="section_mid">
 			</div>
-			<div class="bereich" id="bereich_rechts">
+			<div class="section" id="section_right">
 			</div>
 		</div>
-		<div id="hilfe">
+		<div id="help">
-			<p id="hilfe_einleitung"></p>
+			<p id="help_introduction"></p>
-			<section class="bereich">
+			<section class="section">
-				<header id="hilfe_steuerung_titel">!translate:hilfe.steuerung.titel</header>
+				<header id="help_controls_title">!translate:help.controls.title</header>
 				<ul>
-					<li id="hilfe_steuerung_eintrag1">!translate:hilfe.steuerung.eintrag1</li>
+					<li id="help_controls_eintrag1">!translate:help.controls.eintrag1</li>
-					<li id="hilfe_steuerung_eintrag2">!translate:hilfe.steuerung.eintrag2</li>
+					<li id="help_controls_eintrag2">!translate:help.controls.eintrag2</li>
 				</ul>
 			</section>
-			<section class="bereich">
+			<section class="section">
-				<header id="hilfe_figur_titel">!translate:aufbau.figur.worter.singular</header>
+				<header id="help_token_title">!translate:model.token.terms.singular</header>
-				<p id="hilfe_figur_satz1">!translate:hilfe.figur.satz1</p>
+				<p id="help_token_satz1">!translate:help.token.satz1</p>
-				<p id="hilfe_figur_satz2">!translate:hilfe.figur.satz2</p>
+				<p id="help_token_satz2">!translate:help.token.satz2</p>
 			</section>
-			<section class="bereich" id="hilfe_aktoren">
+			<section class="section" id="help_actuators">
-				<header id="hilfe_aktoren_titel">!translate:aufbau.aktoren.woerter.plural</header>
+				<header id="help_actuators_title">!translate:model.actuators.terms.plural</header>
-				<p id="hilfe_aktoren_einleitung">!translate:hilfe.aktoren.einleitung</p>
+				<p id="help_actuators_introduction">!translate:help.actuators.introduction</p>
 				<ul>
-					<li class="hilfe_aktoren_aktor" id="hilfe_aktoren_aktor_erzeuger">
+					<li class="help_actuators_actuator" id="help_actuators_actuator_erzeuger">
-						<header class="hilfe_aktoren_aktor_name">!translate:aufbau.aktoren.arten.erzeuger.name</header>
+						<header class="help_actuators_actuator_name">!translate:model.actuators.kinds.erzeuger.name</header>
-						<div class="hilfe_aktoren_aktor_bild"></div>
+						<div class="help_actuators_actuator_image"></div>
-						<div class="hilfe_aktoren_aktor_text">!translate:hilfe.aktoren.erzeuger</div>
+						<div class="help_actuators_actuator_text">!translate:help.actuators.erzeuger</div>
 					</li>
-					<li class="hilfe_aktoren_aktor" id="hilfe_aktoren_aktor_annehmer">
+					<li class="help_actuators_actuator" id="help_actuators_actuator_annehmer">
-						<header class="hilfe_aktoren_aktor_name">!translate:aufbau.aktoren.arten.annehmer.name</header>
+						<header class="help_actuators_actuator_name">!translate:model.actuators.kinds.annehmer.name</header>
-						<div class="hilfe_aktoren_aktor_bild"></div>
+						<div class="help_actuators_actuator_image"></div>
-						<div class="hilfe_aktoren_aktor_text">!translate:hilfe.aktoren.annehmer</div>
+						<div class="help_actuators_actuator_text">!translate:help.actuators.annehmer</div>
 					</li>
-					<li class="hilfe_aktoren_aktor" id="hilfe_aktoren_aktor_verwerfer">
+					<li class="help_actuators_actuator" id="help_actuators_actuator_verwerfer">
-						<header class="hilfe_aktoren_aktor_name">!translate:aufbau.aktoren.arten.verwerfer.name</header>
+						<header class="help_actuators_actuator_name">!translate:model.actuators.kinds.verwerfer.name</header>
-						<div class="hilfe_aktoren_aktor_bild"></div>
+						<div class="help_actuators_actuator_image"></div>
-						<div class="hilfe_aktoren_aktor_text">!translate:hilfe.aktoren.verwerfer</div>
+						<div class="help_actuators_actuator_text">!translate:help.actuators.verwerfer</div>
 					</li>
-					<li class="hilfe_aktoren_aktor" id="hilfe_aktoren_aktor_befoerderer">
+					<li class="help_actuators_actuator" id="help_actuators_actuator_befoerderer">
-						<header class="hilfe_aktoren_aktor_name">!translate:aufbau.aktoren.arten.befoerderer.name</header>
+						<header class="help_actuators_actuator_name">!translate:model.actuators.kinds.befoerderer.name</header>
-						<div class="hilfe_aktoren_aktor_bild"></div>
+						<div class="help_actuators_actuator_image"></div>
-						<div class="hilfe_aktoren_aktor_text">!translate:hilfe.aktoren.befoerderer</div>
+						<div class="help_actuators_actuator_text">!translate:help.actuators.befoerderer</div>
 					</li>
-					<li class="hilfe_aktoren_aktor" id="hilfe_aktoren_aktor_schreiber">
+					<li class="help_actuators_actuator" id="help_actuators_actuator_schreiber">
-						<header class="hilfe_aktoren_aktor_name">!translate:aufbau.aktoren.arten.schreiber.name</header>
+						<header class="help_actuators_actuator_name">!translate:model.actuators.kinds.schreiber.name</header>
-						<div class="hilfe_aktoren_aktor_bild"></div>
+						<div class="help_actuators_actuator_image"></div>
-						<div class="hilfe_aktoren_aktor_text">!translate:hilfe.aktoren.schreiber</div>
+						<div class="help_actuators_actuator_text">!translate:help.actuators.schreiber</div>
 					</li>
-					<li class="hilfe_aktoren_aktor" id="hilfe_aktoren_aktor_leser">
+					<li class="help_actuators_actuator" id="help_actuators_actuator_leser">
-						<header class="hilfe_aktoren_aktor_name">!translate:aufbau.aktoren.arten.leser.name</header>
+						<header class="help_actuators_actuator_name">!translate:model.actuators.kinds.leser.name</header>
-						<div class="hilfe_aktoren_aktor_bild"></div>
+						<div class="help_actuators_actuator_image"></div>
-						<div class="hilfe_aktoren_aktor_text">!translate:hilfe.aktoren.leser</div>
+						<div class="help_actuators_actuator_text">!translate:help.actuators.leser</div>
 					</li>
 				</ul>
 			</section>
-			<section class="bereich">
+			<section class="section">
-				<header id="hilfe_aufgaben_titel">!translate:aufbau.aufgaben.woerter.plural</header>
+				<header id="help_tasks_title">!translate:model.tasks.terms.plural</header>
-				<p id="hilfe_aufgaben_einleitung">!translate:hilfe.aufgaben.einleitung</p>
+				<p id="help_tasks_introduction">!translate:help.tasks.introduction</p>
 				<ul>
-					<li id="hilfe_aufgaben_akzeptor">
+					<li id="help_tasks_acceptor">
-						<header id="hilfe_aufgaben_akzeptor_name">!translate:aufbau.aufgaben.arten.akzeptor.name</header>
+						<header id="help_tasks_acceptor_name">!translate:model.tasks.kinds.acceptor.name</header>
-						<p id="hilfe_aufgaben_akzeptor_erklaerung">!translate:hilfe.aufgaben.akzeptor.erklaerung</p>
+						<p id="help_tasks_acceptor_description">!translate:help.tasks.acceptor.description</p>
-						<p id="hilfe_aufgaben_akzeptor_beispiel">!translate:hilfe.aufgaben.akzeptor.beispiel</p>
+						<p id="help_tasks_acceptor_example">!translate:help.tasks.acceptor.example</p>
 					</li>
-					<li id="hilfe_aufgaben_transduktor">
+					<li id="help_tasks_transductor">
-						<header id="hilfe_aufgaben_akzeptor_name">!translate:aufbau.aufgaben.arten.transduktor.name</header>
+						<header id="help_tasks_acceptor_name">!translate:model.tasks.kinds.transductor.name</header>
-						<p id="hilfe_aufgaben_transduktor_erklaerung">!translate:hilfe.aufgaben.transduktor.erklaerung</p>
+						<p id="help_tasks_transductor_description">!translate:help.tasks.transductor.description</p>
-						<p id="hilfe_aufgaben_transduktor_beispiel">!translate:hilfe.aufgaben.transduktor.beispiel</p>
+						<p id="help_tasks_transductor_example">!translate:help.tasks.transductor.example</p>
 					</li>
 				</ul>
 			</section>

quelldatein/manifestation/web/vtm.scss

@@ -63,32 +63,32 @@ body > header
 		margin: 8px;
 	}
 
-#radio_hilfe,
+#radio_help,
-#radio_spiel
+#radio_game
 	{
 		display: none;
 	}
 
-#radio_hilfe:checked
+#radio_help:checked
 	{
-		& ~ #hilfe {}
+		& ~ #help {}
-		& ~ #spiel {display: none;}
+		& ~ #game {display: none;}
 	}
 
-#radio_spiel:checked
+#radio_game:checked
 	{
-		& ~ #hilfe {display: none;}
+		& ~ #help {display: none;}
-		& ~ #spiel {}
+		& ~ #game {}
 	}
 
-#spiel
+#game
 	{
 		display: flex;
 		flex-direction: row;
 		flex-wrap: nowrap;
 	}
 
-.bereich
+.section
 	{
 		margin: 8px;
 		padding: 8px;
@@ -97,14 +97,14 @@ body > header
 		color: hsl(120, 0%, 87.5%);
 	}
 
-#bereich_links
+#section_left
 	{
 		flex-basis: 19%;
 		flex-grow: 1;
 		flex-shrink: 1;
 	}
 
-#bereich_mitte
+#section_mid
 	{
 		flex-basis: 62%;
 		flex-grow: 1;
@@ -115,19 +115,19 @@ body > header
 		text-align: center;
 	}
 
-#bereich_rechts
+#section_right
 	{
 		flex-basis: 19%;
 		flex-grow: 1;
 		flex-shrink: 1;
 	}
 
-#hilfe section > header
+#help section > header
 	{
 		font-size: 150%;
 	}
 
-#knoepfe
+#buttons
 	{
 		& > *
 			{
@@ -136,47 +136,47 @@ body > header
 		
 		&.initial
 			{
-				& > #knopf_schritt {}
+				& > #button_step {}
-				& > #knopf_testen {}
+				& > #button_run {}
-				& > #knopf_anhalten {display: none;}
+				& > #button_stop {display: none;}
-				& > #knopf_bearbeiten {display: none;}
+				& > #button_edit {display: none;}
-				& > #knopf_leeren {}
+				& > #button_clear {}
 			}
 		
-		&.ungewiss_laufend
+		&.uncertain_running
 			{
-				& > #knopf_schritt {display: none;}
+				& > #button_step {display: none;}
-				& > #knopf_testen {display: none;}
+				& > #button_run {display: none;}
-				& > #knopf_anhalten {}
+				& > #button_stop {}
-				& > #knopf_bearbeiten {display: none;}
+				& > #button_edit {display: none;}
-				& > #knopf_leeren {display: none;}
+				& > #button_clear {display: none;}
 			}
 		
-		&.ungewiss_stehend
+		&.uncertain_standing
 			{
-				& > #knopf_schritt {}
+				& > #button_step {}
-				& > #knopf_testen {}
+				& > #button_run {}
-				& > #knopf_anhalten {display: none;}
+				& > #button_stop {display: none;}
-				& > #knopf_bearbeiten {}
+				& > #button_edit {}
-				& > #knopf_leeren {display: none;}
+				& > #button_clear {display: none;}
 			}
 		
-		&.fertig
+		&.done
 			{
-				& > #knopf_schritt {display: none;}
+				& > #button_step {display: none;}
-				& > #knopf_testen {display: none;}
+				& > #button_run {display: none;}
-				& > #knopf_anhalten {display: none;}
+				& > #button_stop {display: none;}
-				& > #knopf_bearbeiten {}
+				& > #button_edit {}
-				& > #knopf_leeren {display: none;}
+				& > #button_clear {display: none;}
 			}
 	}
 
-#aufgabe_status
+#task_status
 	{
 		margin-bottom: 8px;
 	}
 
-.hilfe_aktoren_aktor
+.help_actuators_actuator
 	{
 		display: flex;
 		flex-direction: row;
@@ -184,7 +184,7 @@ body > header
 		
 		margin-bottom: 16px;
 
-		& > .hilfe_aktoren_aktor_name
+		& > .help_actuators_actuator_name
 			{
 				flex-basis: 100%;
 				flex-shrink: 0;
@@ -194,14 +194,14 @@ body > header
 				font-weight: bold;
 			}
 		
-		& > .hilfe_aktoren_aktor_bild
+		& > .help_actuators_actuator_image
 			{
 				flex-basis: 10%;
 				flex-shrink: 1;
 				flex-grow: 0;
 			}
 		
-		& > .hilfe_aktoren_aktor_text
+		& > .help_actuators_actuator_text
 			{
 				flex-basis: 90%;
 				flex-shrink: 1;