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

save

Browse source
This commit is contained in:
Christian Fraß 2018-03-28 13:59:29 +02:00
parent 6dca386ce6
commit 3193117543
51 changed files with 1866 additions and 1854 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -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;
drehen : (aktor : typ_aktor, inkrement : int)=>void;
verwenden : (aktor : typ_aktor, figur : mod_figur.typ_figur)=>void;
exportieren : (aktor : typ_aktor)=>any;
importieren : (roh : any)=>typ_aktor;
example : ()=>type_actuator;
rotate : (actuator : type_actuator, inkrement : int)=>void;
use : (actuator : type_actuator, token : mod_token.type_token)=>void;
export : (actuator : type_actuator)=>any;
import : (raw : any)=>type_actuator;
}
;
@ -48,16 +48,16 @@ module mod_vtm
/**
* @author kcf <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);
}
}

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

@ -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,
figur : mod_figur.typ_figur
annehmer : type_annehmer,
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,
art,
trait_actuator,
kind,
{
"beispiel": () => lib_aufruf.einpacken(art, beispiel()),
"drehen": (aktor, inkrement) => drehen(lib_aufruf.auspacken(aktor), inkrement),
"verwenden": (aktor, figur) => verwenden(lib_aufruf.auspacken(aktor), figur),
"exportieren": (aktor) => ({"art": art, "angaben": exportieren(aktor.angaben)}),
"importieren": (roh) => lib_aufruf.einpacken(art, importieren(roh["angaben"])),
"example": () => lib_call.wrap(kind, example()),
"rotate": (actuator, inkrement) => rotate(lib_call.unwrap(actuator), inkrement),
"use": (actuator, token) => use(lib_call.unwrap(actuator), token),
"export": (actuator) => ({"kind": kind, "data": export_(actuator.data)}),
"import": (raw) => lib_call.wrap(kind, import_(raw["data"])),
}
)
;

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

@ -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,
figur : mod_figur.typ_figur
befoerderer : type_befoerderer,
token : mod_token.type_token
)
: void
{
mod_figur.bewegen(figur, befoerderer.richtung);
mod_token.move(token, befoerderer.direction);
}
/**
* @author kcf <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,
art,
trait_actuator,
kind,
{
"beispiel": () => lib_aufruf.einpacken(art, beispiel()),
"drehen": (aktor, inkrement) => drehen(lib_aufruf.auspacken(aktor), inkrement),
"verwenden": (aktor, figur) => verwenden(lib_aufruf.auspacken(aktor), figur),
"exportieren": (aktor) => ({"art": art, "angaben": exportieren(aktor.angaben)}),
"importieren": (roh) => lib_aufruf.einpacken(art, importieren(roh["angaben"])),
"example": () => lib_call.wrap(kind, example()),
"rotate": (actuator, inkrement) => rotate(lib_call.unwrap(actuator), inkrement),
"use": (actuator, token) => use(lib_call.unwrap(actuator), token),
"export": (actuator) => ({"kind": kind, "data": export_(actuator.data)}),
"import": (raw) => lib_call.wrap(kind, import_(raw["data"])),
}
)
;

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

@ -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,
figur : mod_figur.typ_figur
erzeuger : type_erzeuger,
token : mod_token.type_token
)
: void
{
mod_figur.bewegen(figur, erzeuger.richtung);
mod_token.move(token, erzeuger.direction);
}
/**
* @author kcf <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,
art,
trait_actuator,
kind,
{
"beispiel": () => lib_aufruf.einpacken(art, beispiel()),
"drehen": (aktor, inkrement) => drehen(lib_aufruf.auspacken(aktor), inkrement),
"verwenden": (aktor, figur) => verwenden(lib_aufruf.auspacken(aktor), figur),
"exportieren": (aktor) => ({"art": art, "angaben": exportieren(aktor.angaben)}),
"importieren": (roh) => lib_aufruf.einpacken(art, importieren(roh["angaben"])),
"example": () => lib_call.wrap(kind, example()),
"rotate": (actuator, inkrement) => rotate(lib_call.unwrap(actuator), inkrement),
"use": (actuator, token) => use(lib_call.unwrap(actuator), token),
"export": (actuator) => ({"kind": kind, "data": export_(actuator.data)}),
"import": (raw) => lib_call.wrap(kind, import_(raw["data"])),
}
)
;

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

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

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

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

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

@ -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,
figur : mod_figur.typ_figur
verwerfer : type_verwerfer,
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,
art,
trait_actuator,
kind,
{
"beispiel": () => lib_aufruf.einpacken(art, beispiel()),
"drehen": (aktor, inkrement) => drehen(lib_aufruf.auspacken(aktor), inkrement),
"verwenden": (aktor, figur) => verwenden(lib_aufruf.auspacken(aktor), figur),
"exportieren": (aktor) => ({"art": art, "angaben": exportieren(aktor.angaben)}),
"importieren": (roh) => lib_aufruf.einpacken(art, importieren(roh["angaben"])),
"example": () => lib_call.wrap(kind, example()),
"rotate": (actuator, inkrement) => rotate(lib_call.unwrap(actuator), inkrement),
"use": (actuator, token) => use(lib_call.unwrap(actuator), token),
"export": (actuator) => ({"kind": kind, "data": export_(actuator.data)}),
"import": (raw) => lib_call.wrap(kind, import_(raw["data"])),
}
)
;

32
quelldatein/aufbau/aufgaben/akzeptoraufgabe.ts
View file

@ -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;
}
}

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

@ -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>;
annehmen : boolean;
input : Array<mod_vtm.mod_model.mod_symbol.type_symbol>;
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>,
annehmen : boolean
input : Array<mod_vtm.mod_model.mod_symbol.type_symbol>,
accept : boolean
)
: typ_akzeptortest
: type_acceptortest
{
return {
"eingabe": eingabe,
"annehmen": annehmen,
"input": input,
"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,
angenommen : boolean,
ausgabe : Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>
acceptortest : type_acceptortest,
accepted : boolean,
ausgabe : Array<mod_vtm.mod_model.mod_symbol.type_symbol>
)
: boolean
{
return (akzeptortest.annehmen === angenommen);
return (acceptortest.accept === accepted);
}
}

120
quelldatein/aufbau/aufgaben/aufgabe.ts
View file

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

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

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

32
quelldatein/aufbau/aufgaben/transduktoraufgabe.ts
View file

@ -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;
}
}

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

@ -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>;
ausgabe : Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>;
input : Array<mod_vtm.mod_model.mod_symbol.type_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>,
ausgabe : Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>
input : Array<mod_vtm.mod_model.mod_symbol.type_symbol>,
output : Array<mod_vtm.mod_model.mod_symbol.type_symbol>
)
: typ_transduktortest
: type_transductortest
{
return {
"eingabe": eingabe,
"ausgabe": ausgabe,
"input": input,
"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,
angenommen : boolean,
ausgabe : Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol>
transductortest : type_transductortest,
accepted : boolean,
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;

104
quelldatein/aufbau/figur.ts
View file

@ -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;
band : Array<mod_symbol.typ_symbol>;
stelle : mod_stelle.typ_stelle;
state : mod_state.type_state;
tape : Array<mod_symbol.type_symbol>;
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> = [],
stelle : mod_stelle.typ_stelle = mod_stelle.null_()
tape : Array<mod_symbol.type_symbol> = [],
spot : mod_spot.type_spot = mod_spot.null_()
)
: typ_figur
: type_token
{
return {
"zustand": mod_zustand.laufend,
"band": band,
"stelle": stelle,
"state": mod_state.running,
"tape": tape,
"spot": spot,
};
}
@ -58,87 +58,87 @@ module mod_vtm
/**
* @author kcf <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,
richtung : mod_richtung.typ_richtung
token : type_token,
direction : mod_direction.type_direction
)
: void
{
let summand : mod_stelle.typ_stelle = mod_stelle.von_richtung(richtung);
figur.stelle = mod_stelle.addieren(figur.stelle, summand);
let summand : mod_spot.type_spot = mod_spot.von_direction(direction);
token.spot = mod_spot.add(token.spot, summand);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function schreiben
export function write
(
figur : typ_figur,
symbol : mod_symbol.typ_symbol
token : type_token,
symbol : mod_symbol.type_symbol
)
: void
{
figur.band.push(symbol);
token.tape.push(symbol);
}
/**
* @author kcf <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";
throw (new Error(meldung));
let message : string = "Band ist leer";
throw (new Error(message));
}
else
{
figur.band.shift();
token.tape.shift();
}
}
@ -167,26 +167,26 @@ module mod_vtm
/**
* @author kcf <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;
}
}

12
quelldatein/aufbau/modus.ts
View file

@ -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 fehlerhaft = 2;
export const korrekt = 3;
export const uncertain = 1;
export const wrong = 2;
export const correct = 3;
}

336
quelldatein/aufbau/partie.ts
View file

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

18
quelldatein/aufbau/richtung.ts
View file

@ -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_;
}
}

32
quelldatein/aufbau/stelle.ts
View file

@ -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_);
}
}

10
quelldatein/aufbau/symbol.ts
View file

@ -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_;
}

234
quelldatein/aufbau/welt.ts
View file

@ -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;}> = [];
lib_hashmap.iterieren
let tiles : Array<{spot : mod_spot.type_spot; actuator : mod_actuator.type_actuator;}> = [];
lib_hashmap.iterate
(
welt.felder,
(stelle, aktor) => felder.push({"stelle": stelle, "aktor": aktor})
world.tiles,
(spot, actuator) => tiles.push({"spot": spot, "actuator": actuator})
)
;
return felder;
return tiles;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function feld_holen
export function tile_get
(
welt : typ_welt,
stelle : mod_stelle.typ_stelle
world : type_world,
spot : mod_spot.type_spot
)
: lib_fehlermonade.typ_fehlermonade<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,
stelle : mod_stelle.typ_stelle,
aktor : mod_aktor.typ_aktor
world : type_world,
spot : mod_spot.type_spot,
actuator : mod_actuator.type_actuator
)
: void
{
lib_hashmap.setzen(welt.felder, stelle, aktor);
lib_hashmap.set(world.tiles, spot, actuator);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function feld_wechseln
export function tile_wechseln
(
welt : typ_welt,
stelle : mod_stelle.typ_stelle,
world : type_world,
spot : mod_spot.type_spot,
umgekehrt : boolean = false
)
: void
{
let erweitert : boolean = true;
let liste : Array<{pruefer : (aktor : mod_aktor.typ_aktor)=>boolean; ersteller : ()=>mod_aktor.typ_aktor;}> = (
let liste : Array<{pruefer : (actuator : mod_actuator.type_actuator)=>boolean; erspotr : ()=>mod_actuator.type_actuator;}> = (
[]
.concat
(
[
{
"pruefer": (aktor) => (aktor.art === "befoerderer"),
"ersteller": () => mod_aktor.mod_befoerderer.erstellen_aktor(0),
"pruefer": (actuator) => (actuator.kind === "befoerderer"),
"erspotr": () => mod_actuator.mod_befoerderer.create_actuator(0),
},
]
)
.concat
(
mod_vtm.mod_helfer.sequenz(erweitert ? 4 : 2).map
mod_vtm.mod_helfer.sequence(erweitert ? 4 : 2).map
(
symbol => (
{
"pruefer": (aktor) =>
"pruefer": (actuator) =>
{
if (aktor.art === "schreiber")
if (actuator.kind === "schreiber")
{
return (mod_aktor.mod_schreiber.symbol_lesen(aktor.angaben) === symbol);
return (mod_actuator.mod_schreiber.symbol_read(actuator.data) === symbol);
}
else
{
@ -140,29 +140,29 @@ module mod_vtm
}
}
,
"ersteller": () => mod_aktor.mod_schreiber.erstellen_aktor(0, symbol)
"erspotr": () => mod_actuator.mod_schreiber.create_actuator(0, symbol)
}
)
)
)
.concat
(
mod_vtm.mod_helfer.sequenz(erweitert ? 2 : 1).map
mod_vtm.mod_helfer.sequence(erweitert ? 2 : 1).map
(
index =>
{
let symbol_links : mod_symbol.typ_symbol = (2*index+0);
let symbol_rechts : mod_symbol.typ_symbol = (2*index+1);
let symbol_links : mod_symbol.type_symbol = (2*index+0);
let symbol_rechts : mod_symbol.type_symbol = (2*index+1);
return (
{
"pruefer": (aktor) =>
"pruefer": (actuator) =>
{
if (aktor.art === "leser")
if (actuator.kind === "leser")
{
return (
(mod_aktor.mod_leser.symbol_links_lesen(aktor.angaben) === symbol_links)
(mod_actuator.mod_leser.symbol_links_read(actuator.data) === symbol_links)
&&
(mod_aktor.mod_leser.symbol_rechts_lesen(aktor.angaben) === symbol_rechts)
(mod_actuator.mod_leser.symbol_rechts_read(actuator.data) === symbol_rechts)
);
}
else
@ -171,7 +171,7 @@ module mod_vtm
}
}
,
"ersteller": () => mod_aktor.mod_leser.erstellen_aktor(0, symbol_links, symbol_rechts)
"erspotr": () => mod_actuator.mod_leser.create_actuator(0, symbol_links, symbol_rechts)
}
);
}
@ -181,25 +181,25 @@ module mod_vtm
(
[
{
"pruefer": (aktor) => (aktor.art === "verwerfer"),
"ersteller": () => mod_aktor.mod_verwerfer.erstellen_aktor(),
"pruefer": (actuator) => (actuator.kind === "verwerfer"),
"erspotr": () => mod_actuator.mod_verwerfer.create_actuator(),
},
]
)
);
let index_alt : lib_fehlermonade.typ_fehlermonade<int>;
let aktor_alt_ : lib_fehlermonade.typ_fehlermonade<mod_aktor.typ_aktor> = lib_hashmap.holen(welt.felder, stelle);
if (lib_fehlermonade.voll<mod_aktor.typ_aktor>(aktor_alt_))
let index_alt : lib_errormonade.type_errormonade<int>;
let actuator_alt_ : lib_errormonade.type_errormonade<mod_actuator.type_actuator> = lib_hashmap.get(world.tiles, spot);
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";
// console.warn(meldung);
index_alt = (lib_fehlermonade.erstellen_schlicht<int>(0));
let message : string = "kein Aktor gesetzt";
// console.warn(message);
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 aktor_neu : mod_aktor.typ_aktor = liste[index_neu].ersteller();
feld_setzen(welt, stelle, aktor_neu);
let index_neu : int = lib_math.mod(lib_errormonade.read<int>(index_alt) + (umgekehrt ? -1 : +1), liste.length);
let actuator_neu : mod_actuator.type_actuator = liste[index_neu].erspotr();
tile_set(world, spot, actuator_neu);
}
else
{
let meldung : string = ("Aktor nicht gefunden");
// throw (new Error(meldung));
console.warn(meldung);
let message : string = ("Aktor nicht gefunden");
// throw (new Error(message));
console.warn(message);
}
}
@ -242,18 +242,18 @@ module mod_vtm
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function feld_drehen
export function tile_rotate
(
welt : typ_welt,
stelle : mod_stelle.typ_stelle,
world : type_world,
spot : mod_spot.type_spot,
inkrement : int = +1
)
: void
{
let aktor_ : lib_fehlermonade.typ_fehlermonade<mod_aktor.typ_aktor> = lib_hashmap.holen(welt.felder, stelle);
if (lib_fehlermonade.voll<mod_aktor.typ_aktor>(aktor_))
let actuator_ : lib_errormonade.type_errormonade<mod_actuator.type_actuator> = lib_hashmap.get(world.tiles, spot);
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>());
lib_hashmap.iterieren
let spot : lib_errormonade.type_errormonade<mod_spot.type_spot> = (lib_errormonade.create_nothing<mod_spot.type_spot>());
lib_hashmap.iterate
(
welt.felder,
(stelle_, aktor) =>
world.tiles,
(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";
throw (new Error(meldung));
let message : string = "mehrere Erzeuger gefunden";
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";
throw (new Error(meldung));
let message : string = "kein Erzeuger gefunden";
throw (new Error(message));
}
}
@ -312,84 +312,84 @@ module mod_vtm
(
groesse : int = 3
)
: typ_welt
: type_world
{
let welt : typ_welt = erstellen();
let world : type_world = create();
for (let u : int = -groesse; u <= +groesse; u += 1)
{
for (let v : int = -groesse; v <= +groesse; v += 1)
{
if (Math.abs(u-v) <= groesse)
{
let stelle : mod_stelle.typ_stelle = {"u": u, "v": v};
let aktor : mod_aktor.typ_aktor;
let spot : mod_spot.type_spot = {"u": u, "v": v};
let actuator : mod_actuator.type_actuator;
if ((u === -groesse) && (v === 0))
{
aktor = mod_aktor.mod_erzeuger.erstellen_aktor(0);
actuator = mod_actuator.mod_erzeuger.create_actuator(0);
}
else if ((u === +groesse) && (v === 0))
{
aktor = mod_aktor.mod_annehmer.erstellen_aktor();
actuator = mod_actuator.mod_annehmer.create_actuator();
}
else
{
aktor = mod_aktor.mod_verwerfer.erstellen_aktor();
actuator = mod_actuator.mod_verwerfer.create_actuator();
}
lib_hashmap.setzen(welt.felder, stelle, aktor);
lib_hashmap.set(world.tiles, spot, actuator);
}
}
}
return welt;
return world;
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function exportieren
export function export_
(
welt : typ_welt
world : type_world
)
: any
{
let roh : any = {};
roh["felder"] = {};
lib_hashmap.iterieren
let raw : any = {};
raw["tiles"] = {};
lib_hashmap.iterate
(
welt.felder,
(stelle, aktor) =>
world.tiles,
(spot, actuator) =>
{
let stelle_ : string = mod_stelle.exportieren(stelle);
let aktor_ : any = mod_aktor.exportieren(aktor);
roh["felder"][stelle_] = aktor_;
let spot_ : string = mod_spot.export_(spot);
let actuator_ : any = mod_actuator.export_(actuator);
raw["tiles"][spot_] = actuator_;
}
)
;
return roh;
return raw;
}
/**
* @author kcf <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));
for (let stelle_ in roh["felder"])
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 spot_ in raw["tiles"])
{
let stelle : mod_stelle.typ_stelle = mod_stelle.importieren(stelle_);
let aktor_ : mod_aktor.typ_aktor = roh["felder"][stelle_];
let aktor : mod_aktor.typ_aktor = mod_aktor.importieren(aktor_);
lib_hashmap.setzen(felder, stelle, aktor);
let spot : mod_spot.type_spot = mod_spot.import_(spot_);
let actuator_ : mod_actuator.type_actuator = raw["tiles"][spot_];
let actuator : mod_actuator.type_actuator = mod_actuator.import_(actuator_);
lib_hashmap.set(tiles, spot, actuator);
}
return (
erstellen
create
(
felder
tiles
)
);
}

12
quelldatein/aufbau/zustand.ts
View file

@ -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 laufend = 0;
export var angenommen = +1;
export var rejected = -1;
export var running = 0;
export var accepted = +1;
}

20
quelldatein/daten.ts
View file

@ -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);
}

184
quelldatein/daten/aufgaben.dat.js
View file

@ -1,253 +1,253 @@
jsonp_behandlung(
jsonp_handle(
{
"schluessel": "aufgaben",
"wert": [
"key": "tasks",
"value": [
{
"id": "einfuehrung",
"art": "akzeptor",
"kind": "acceptor",
"parameter": {
"titel": "Einführung",
"text": "Bewege die Figur vom Eingang (links) zum Ausgang (rechts)!",
"tests": [
{
"eingabe": [],
"annehmen": true
"input": [],
"accept": true
}
]
}
},
{
"id": "start_symbol",
"art": "akzeptor",
"kind": "acceptor",
"parameter": {
"titel": "Start-Symbol",
"text": "Annehmen, wenn die Eingabe mit ${s1} beginnt; andernfalls ablehnen",
"text": "Annehmen, wenn die input mit ${s1} beginnt; andernfalls ablehnen",
"tests": [
{
"eingabe": [],
"annehmen": false
"input": [],
"accept": false
},
{
"eingabe": [0],
"annehmen": false
"input": [0],
"accept": false
},
{
"eingabe": [1],
"annehmen": true
"input": [1],
"accept": true
},
{
"eingabe": [0,1],
"annehmen": false
"input": [0,1],
"accept": false
},
{
"eingabe": [1,0,1,1,0,0,0,1,0],
"annehmen": true
"input": [1,0,1,1,0,0,0,1,0],
"accept": true
}
]
}
},
{
"id": "dreifaltigkeit",
"art": "akzeptor",
"kind": "acceptor",
"parameter": {
"titel": "Dreifaltigkeit",
"text": "Annehmen genau dann, wenn die Eingabe mindestens drei ${s1} enthält",
"text": "Annehmen genau dann, wenn die input mindestens drei ${s1} enthält",
"tests": [
{
"eingabe": [1],
"annehmen": false
"input": [1],
"accept": false
},
{
"eingabe": [0,0,1,1],
"annehmen": false
"input": [0,0,1,1],
"accept": false
},
{
"eingabe": [1,0,1,0,0,1,0],
"annehmen": true
"input": [1,0,1,0,0,1,0],
"accept": true
}
]
}
},
{
"id": "abwechslung_erfreuet",
"art": "akzeptor",
"kind": "acceptor",
"parameter": {
"titel": "Abwechslung erfreuet",
"text": "annehmen genau dann wenn: Die Farben der Eingabe (${s0} / ${s1}) sich immer abwechseln",
"text": "annehmen genau dann wenn: Die Farben der input (${s0} / ${s1}) sich immer abwechseln",
"tests": [
{
"eingabe": [],
"annehmen": true
"input": [],
"accept": true
},
{
"eingabe": [0],
"annehmen": true
"input": [0],
"accept": true
},
{
"eingabe": [0,0],
"annehmen": false
"input": [0,0],
"accept": false
},
{
"eingabe": [1,0,1],
"annehmen": true
"input": [1,0,1],
"accept": true
},
{
"eingabe": [0,1,0,1,0,1],
"annehmen": true
"input": [0,1,0,1,0,1],
"accept": true
}
]
}
},
{
"id": "ans_ende",
"art": "transduktor",
"kind": "transductor",
"parameter": {
"titel": "Ans Ende",
"text": "die Eingabe (${s0} / ${s1}), aber mit dem ersten Symbol am Ende",
"text": "die input (${s0} / ${s1}), aber mit dem ersten Symbol am Ende",
"tests": [
{
"eingabe": [0,0,1,1,1,0,1,0,1,1,1,0,1],
"ausgabe": [0,1,1,1,0,1,0,1,1,1,0,1,0]
"input": [0,0,1,1,1,0,1,0,1,1,1,0,1],
"output": [0,1,1,1,0,1,0,1,1,1,0,1,0]
}
]
}
},
{
"id": "tauschen",
"art": "transduktor",
"kind": "transductor",
"parameter": {
"titel": "Tauschen",
"text": "aus der Eingabe (${s0} / ${s1}) alle ${s0} durch ${s2} ersetzen und alle ${s1} durch ${s3}",
"text": "aus der input (${s0} / ${s1}) alle ${s0} durch ${s2} ersetzen und alle ${s1} durch ${s3}",
"tests": [
{
"eingabe": [0,1,1,0],
"ausgabe": [2,3,3,2]
"input": [0,1,1,0],
"output": [2,3,3,2]
},
{
"eingabe": [0,1,0,1,0,1,1,0,0,0,0,1,0,1,1,0],
"ausgabe": [2,3,2,3,2,3,3,2,2,2,2,3,2,3,3,2]
"input": [0,1,0,1,0,1,1,0,0,0,0,1,0,1,1,0],
"output": [2,3,2,3,2,3,3,2,2,2,2,3,2,3,3,2]
}
]
}
},
{
"id": "waehlerisch",
"art": "transduktor",
"kind": "transductor",
"parameter": {
"titel": "Wählerisch",
"text": "aus der Eingabe alle ${s0} entfernen und alle ${s1} beibehalten",
"text": "aus der input alle ${s0} entfernen und alle ${s1} beibehalten",
"tests": [
{
"eingabe": [0,0,0,1,0],
"ausgabe": [1]
"input": [0,0,0,1,0],
"output": [1]
},
{
"eingabe": [1,0,1,0,1],
"ausgabe": [1,1,1]
"input": [1,0,1,0,1],
"output": [1,1,1]
},
{
"eingabe": [1,1,1,1,0],
"ausgabe": [1,1,1,1]
"input": [1,1,1,1,0],
"output": [1,1,1,1]
},
{
"eingabe": [0,0,0,0,1,0,1,1,0],
"ausgabe": [1,1,1]
"input": [0,0,0,0,1,0,1,1,0],
"output": [1,1,1]
},
]
}
},
{
"id": "dekorator",
"art": "transduktor",
"kind": "transductor",
"parameter": {
"titel": "Dekorator",
"text": "Alles wird hübscher mit Schnörkeln, Schleifchen und Kinkerlitzchen aller Art! Zumindest glauben das die Leute … Shopping-Sender im Fernsehen sind der Beweis! Ob das auch für das Band der Figur gilt, wenn es nur ${s0} und ${s1} enthält? Finden wir's raus: Setz ein ${s2} an den Anfang und ein ${s3} an das Ende!",
"tests": [
{
"eingabe": [1,1,0],
"ausgabe": [2,1,1,0,3]
"input": [1,1,0],
"output": [2,1,1,0,3]
},
{
"eingabe": [0,0,1,0,0],
"ausgabe": [2,0,0,1,0,0,3]
"input": [0,0,1,0,0],
"output": [2,0,0,1,0,0,3]
}
]
}
},
{
"id": "alpha_und_omega",
"art": "akzeptor",
"kind": "acceptor",
"parameter": {
"titel": "Alpha und Omega",
"text": "Eingaben (${s0} / ${s1}), die mit den gleichen Symbolen anfangen und enden",
"text": "inputn (${s0} / ${s1}), die mit den gleichen Symbolen anfangen und enden",
"tests": [
{
"eingabe": [],
"annehmen": true
"input": [],
"accept": true
},
{
"eingabe": [1],
"annehmen": true
"input": [1],
"accept": true
},
{
"eingabe": [0,1],
"annehmen": false
"input": [0,1],
"accept": false
},
{
"eingabe": [0,1,1,1,0],
"annehmen": true
"input": [0,1,1,1,0],
"accept": true
},
{
"eingabe": [1,1,0,0],
"annehmen": false
"input": [1,1,0,0],
"accept": false
},
{
"eingabe": [1,0,1,1,1],
"annehmen": true
"input": [1,0,1,1,1],
"accept": true
}
]
}
},
{
"id": "an_den_anfang",
"art": "transduktor",
"kind": "transductor",
"parameter": {
"titel": "An den Anfang",
"text": "die Eingabe (${s0} / ${s1}), aber mit dem letzten Symbol am Anfang",
"text": "die input (${s0} / ${s1}), aber mit dem letzten Symbol am Anfang",
"tests": [
{
"eingabe": [0,0,1,1,1,0,1,0,1,1,1,0,1],
"ausgabe": [1,0,0,1,1,1,0,1,0,1,1,1,0]
"input": [0,0,1,1,1,0,1,0,1,1,1,0,1],
"output": [1,0,0,1,1,1,0,1,0,1,1,1,0]
}
]
}
},
{
"id": "a_n_b_n",
"art": "akzeptor",
"kind": "acceptor",
"parameter": {
"titel": "a^n b^n",
"text": "Jaja, die berühmt berüchtige Sprache, die sich mit einem endlichen Automaten nicht erkennen lässt … Das ist deine Chance zu zeigen, dass dieses Ding hier mehr ist als so ein kümmerlicher DEA … und das ganz ohne Kellerspeicher! Also: Eine beliebige Anzahl an ${s0}, dann die gleiche Anzahl an ${s1}!",
"tests": [
{
"eingabe": [],
"annehmen": true
"input": [],
"accept": true
},
{
"eingabe": [0],
"annehmen": false
"input": [0],
"accept": false
},
{
"eingabe": [0,0,1,1],
"annehmen": true
"input": [0,0,1,1],
"accept": true
},
{
"eingabe": [0,0,0,1,1],
"annehmen": false
"input": [0,0,0,1,1],
"accept": false
},
{
"eingabe": [0,0,0,0,0,0,0,1,1,1,1,1,1,1],
"annehmen": true
"input": [0,0,0,0,0,0,0,1,1,1,1,1,1,1],
"accept": true
}
],
"hinweise": [

96
quelldatein/daten/zeichenketten/de.dat.js
View file

@ -1,50 +1,54 @@
jsonp_behandlung(
jsonp_handle(
{
"schluessel": "zeichenketten-de",
"wert": {
"allgemein.titel": "Verrückte Turing-Maschinen",
"allgemein.hilfe": "Hilfe",
"allgemein.spiel": "Spiel",
"aufbau.figur.worter.singular": "Figur",
"aufbau.figur.worter.plural": "Figuren",
"aufbau.aktoren.woerter.singular": "Aktor",
"aufbau.aktoren.woerter.plural": "Aktoren",
"aufbau.aktoren.arten.erzeuger.name": "Eingang",
"aufbau.aktoren.arten.annehmer.name": "Ausgang",
"aufbau.aktoren.arten.verwerfer.name": "Abweiser",
"aufbau.aktoren.arten.befoerderer.name": "Schieber",
"aufbau.aktoren.arten.schreiber.name": "Schreiber",
"aufbau.aktoren.arten.leser.name": "Weiche",
"aufbau.aufgaben.woerter.singular": "Aufgabe",
"aufbau.aufgaben.woerter.plural": "Aufgaben",
"aufbau.aufgaben.arten.akzeptor.name": "Akzeptor",
"aufbau.aufgaben.arten.akzeptor.kuerzel": "AKZ",
"aufbau.aufgaben.arten.transduktor.name": "Transduktor",
"aufbau.aufgaben.arten.transduktor.kuerzel": "TRA",
"steuerung.auswaehlen": "Aufgabe auswählen",
"steuerung.schritt": "Nächster Schritt",
"steuerung.test": "Ablaufen",
"steuerung.anhalten": "Anhalten",
"steuerung.bearbeiten": "Bearbeiten",
"steuerung.leeren": "Leeren",
"hilfe.einleitung": "Dieses Spiel ist inspiriert von !var:manufacturia, !var:crazy_machines, !var:world_of_goo … und auch von unvergessenen Stunden Hardware-Praktikum im Informatik-Studium :P",
"hilfe.steuerung.titel": "Steuerung",
"hilfe.steuerung.eintrag1": "Links-Klick/Rechts-Klick: Feldtyp wechseln",
"hilfe.steuerung.eintrag2": "Mausrad-Drehen: Feld drehen",
"hilfe.figur.satz1": "Die Figur kann durch Aktoren auf dem Spielplan umher bewegt werden und wird als schwarzer Kreis dargestellt.",
"hilfe.figur.satz2": "Zudem verfügt die Figur über ein Liste von gesetzen Symbolen (Band), dargestellt durch farbige Punkte neben der Figur. Gelesen wird das Band immer an der vordersten Stelle und geschrieben wird an die hinterste Stelle (FIFO-Prinzip).",
"hilfe.aktoren.einleitung": "Jedes Feld des Spielplans kann mit einem Aktor bestückt werden, der je nach Typ unterschiedliche Einflüsse auf die Figur ausübt. Folgende Typen stehen zur Verfügung:",
"hilfe.aktoren.erzeuger": "Der Eingang ist fest platziert auf dem ganz linken Feld des Spielplans und wird durch ein weißes Dreieck dargestellt. An ihm wird die Spielfigur auf den Plan gesetzt und bewegt sich anschließend in die angezeigte Richtung.",
"hilfe.aktoren.annehmer": "Auf dem ganz rechten Feld des Spielplans fest platziert befindet sich der Ausgang, der durch einen weißen Kreis dargestellt wird. Steuert man die Figur zu diesem Feld, so wird der aktuelle Band-Inhalt ausgelesen und akzeptiert.",
"hilfe.aktoren.verwerfer": "Jedes leere Feld beendet den Lauf der Figur mit einer Abweisung des aktuellen Band-Inhalts.",
"hilfe.aktoren.befoerderer": "Dieser Aktor dient dazu die Figur von einem Feld zu einem benachbarten zu befördern ohne dabei den Band-Inhalt zu ändern.",
"hilfe.aktoren.schreiber": "Um ein Symbol auf das Band zu schreiben, wird dieser Aktor benötigt. Die jeweilige Farbe gibt an, welches Symbol geschrieben wird und die Richtung zeigt, wohin die Figur anschließend befördert wird.",
"hilfe.aktoren.leser": "An einer Weiche wird das erste Symbol auf dem Band der Figur gelesen und die übereinstimmende Richtung gewählt, zu welcher die Figur im Anschluss bewegt wird. Gibt es einen passenden Ausgang, so wird das gelesene Symbol vom Band entfernt. Falls kein Ausgang gefunden wird oder das Band leer ist, wird der Ersatz-Ausgang (grau) gewählt.",
"hilfe.aufgaben.einleitung": "Ziel ist das Lösen von bestimmten Aufgaben. Dabei wird zwischen zwei Arten von Aufgaben unterschieden:",
"hilfe.aufgaben.akzeptor.erklaerung": "Hierbei geht es darum den Band-Inhalt der Figur zu untersuchen und zu entscheiden, ob er eine bestimmte Bedingung erfüllt oder nicht. Fall ja, so steuert man die Figur in den Ausgang; andernfalls auf ein beliebiges leeres Feld.",
"hilfe.aufgaben.akzeptor.beispiel": "Beispiel: Genau dann akzeptieren, wenn das Band mindestens zwei mal rot enthält.",
"hilfe.aufgaben.transduktor.erklaerung": "Bei einer Transduktor-Aufgabe soll eine Ausgabe erzeugt werden, die in einer bestimmten Beziehung zur vorgefundenen Eingabe steht, also sozusagen eine Funktion angewendet werden.",
"hilfe.aufgaben.transduktor.beispiel": "Beispiel: Die Eingabe zwei mal wiederholt."
"key": "strings-de",
"value": {
"common.title": "Verrückte Turing-Maschinen",
"common.help": "Hilfe",
"common.game": "Spiel",
"model.token.terms.singular": "Figur",
"model.token.terms.plural": "Figuren",
"model.modes.initial": "Maschine bearbeiten",
"model.modes.uncertain": "wird geprüft …",
"model.modes.wrong": "fehlerhaft :/",
"model.modes.correct": "anscheinend korrekt :)",
"model.actuators.terms.singular": "Aktor",
"model.actuators.terms.plural": "Aktoren",
"model.actuators.kinds.erzeuger.name": "Eingang",
"model.actuators.kinds.annehmer.name": "Ausgang",
"model.actuators.kinds.verwerfer.name": "Abweiser",
"model.actuators.kinds.befoerderer.name": "Schieber",
"model.actuators.kinds.schreiber.name": "Schreiber",
"model.actuators.kinds.leser.name": "Weiche",
"model.tasks.terms.singular": "Aufgabe",
"model.tasks.terms.plural": "tasks",
"model.tasks.kinds.acceptor.name": "Akzeptor",
"model.tasks.kinds.acceptor.shortcut": "AKZ",
"model.tasks.kinds.transductor.name": "Transduktor",
"model.tasks.kinds.transductor.shortcut": "TRA",
"controls.choose": "Aufgabe auswählen",
"controls.step": "Nächster Schritt",
"controls.run": "Ablaufen",
"controls.stop": "Anhalten",
"controls.edit": "Bearbeiten",
"controls.clear": "Leeren",
"help.introduction": "Dieses Spiel ist inspiriert von !var:manufacturia, !var:crazy_machines, !var:world_of_goo … und auch von unvergessenen Stunden Hardware-Praktikum im Informatik-Studium :P",
"help.controls.title": "Steuerung",
"help.controls.eintrag1": "Links-Klick/Rechts-Klick: Feldtyp wechseln",
"help.controls.eintrag2": "Mausrad-Drehen: Feld drehen",
"help.token.satz1": "Die Figur kann durch Aktoren auf dem Spielplan umher bewegt werden und wird als schwarzer Kreis dargestellt.",
"help.token.satz2": "Zudem verfügt die Figur über ein Liste von gesetzen Symbolen (Band), dargestellt durch farbige Punkte neben der Figur. Gelesen wird das Band immer an der vordersten Stelle und geschrieben wird an die hinterste Stelle (FIFO-Prinzip).",
"help.actuators.introduction": "Jedes Feld des Spielplans kann mit einem Aktor bestückt werden, der je nach Typ unterschiedliche Einflüsse auf die Figur ausübt. Folgende Typen stehen zur Verfügung:",
"help.actuators.erzeuger": "Der Eingang ist fest platziert auf dem ganz linken Feld des Spielplans und wird durch ein weißes Dreieck dargestellt. An ihm wird die Spieltoken auf den Plan gesetzt und bewegt sich anschließend in die angezeigte Richtung.",
"help.actuators.annehmer": "Auf dem ganz rechten Feld des Spielplans fest platziert befindet sich der Ausgang, der durch einen weißen Kreis dargestellt wird. Steuert man die Figur zu diesem Feld, so wird der aktuelle Band-Inhalt ausgelesen und akzeptiert.",
"help.actuators.verwerfer": "Jedes leere Feld beendet den Lauf der Figur mit einer Abweisung des aktuellen Band-Inhalts.",
"help.actuators.befoerderer": "Dieser Aktor dient dazu die Figur von einem Feld zu einem benachbkinds zu befördern ohne dabei den Band-Inhalt zu ändern.",
"help.actuators.schreiber": "Um ein Symbol auf das Band zu schreiben, wird dieser Aktor benötigt. Die jeweilige Farbe gibt an, welches Symbol geschrieben wird und die Richtung zeigt, wohin die Figur anschließend befördert wird.",
"help.actuators.leser": "An einer Weiche wird das erste Symbol auf dem Band der Figur gelesen und die übereinstimmende Richtung gewählt, zu welcher die Figur im Anschluss bewegt wird. Gibt es einen passenden Ausgang, so wird das gelesene Symbol vom Band entfernt. Falls kein Ausgang gefunden wird oder das Band leer ist, wird der Ersatz-Ausgang (grau) gewählt.",
"help.tasks.introduction": "Ziel ist das Lösen von bestimmten Aufgaben. Dabei wird zwischen zwei Arten von tasks unterschieden:",
"help.tasks.acceptor.description": "Hierbei geht es darum den Band-Inhalt der Figur zu untersuchen und zu entscheiden, ob er eine bestimmte Bedingung erfüllt oder nicht. Fall ja, so steuert man die Figur in den Ausgang; andernfalls auf ein beliebiges leeres Feld.",
"help.tasks.acceptor.example": "Beispiel: Genau dann akzeptieren, wenn das Band mindestens zwei mal rot enthält.",
"help.tasks.transductor.description": "Bei einer Transduktor-Aufgabe soll eine Ausgabe erzeugt werden, die in einer bestimmten Beziehung zur vorgefundenen Eingabe steht, also sozusagen eine Funktion angewendet werden.",
"help.tasks.transductor.example": "Beispiel: Die Eingabe zwei mal wiederholt."
}
}
);

96
quelldatein/daten/zeichenketten/en.dat.js
View file

@ -1,50 +1,54 @@
jsonp_behandlung(
jsonp_handle(
{
"schluessel": "zeichenketten-en",
"wert": {
"allgemein.titel": "Crazy Turing Machines",
"allgemein.hilfe": "Help",
"allgemein.spiel": "Game",
"aufbau.figur.worter.singular": "token",
"aufbau.figur.worter.plural": "tokens",
"aufbau.aktoren.woerter.singular": "actor",
"aufbau.aktoren.woerter.plural": "actors",
"aufbau.aktoren.arten.erzeuger.name": "entrance",
"aufbau.aktoren.arten.annehmer.name": "exit",
"aufbau.aktoren.arten.verwerfer.name": "dropper",
"aufbau.aktoren.arten.befoerderer.name": "conveyer",
"aufbau.aktoren.arten.schreiber.name": "writer",
"aufbau.aktoren.arten.leser.name": "switch",
"aufbau.aufgaben.woerter.singular": "task",
"aufbau.aufgaben.woerter.plural": "tasks",
"aufbau.aufgaben.arten.akzeptor.name": "acceptor",
"aufbau.aufgaben.arten.akzeptor.kuerzel": "ACC",
"aufbau.aufgaben.arten.transduktor.name": "transductor",
"aufbau.aufgaben.arten.transduktor.kuerzel": "TRA",
"steuerung.auswaehlen": "choose task",
"steuerung.schritt": "next step",
"steuerung.test": "run",
"steuerung.anhalten": "stop",
"steuerung.bearbeiten": "edit",
"steuerung.leeren": "clear",
"hilfe.einleitung": "This game is inspired by !var:manufacturia, !var:crazy_machines, !var:world_of_goo … and also by memorable hours of the practical hardware course during computer science study :P",
"hilfe.steuerung.titel": "controls",
"hilfe.steuerung.eintrag1": "left click/right click: change tile type",
"hilfe.steuerung.eintrag2": "rotate mousewheel: rotate tile",
"hilfe.figur.satz1": "The token can be moved around the board by actors and it is displayed as a black circle.",
"hilfe.figur.satz2": "Additionally the token has a list of set symbols (its tape), which is shown as coloured points next to the token. The tape is always read at the front and written at its back (FIFO principle).",
"hilfe.aktoren.einleitung": "Every tile on the board can be equipped with an actor, which will cause a certain effect on the token depending on the type. The following types are available:",
"hilfe.aktoren.erzeuger": "The entrance is statically placed on the most left tile of the board and is displayed as a white triangle. It is the spot at which the token is inserted into the board and moved to the indicated direction afterwards.",
"hilfe.aktoren.annehmer": "On the most right tile of the board the exit is statically placed; it is displayed as a white circle. If the token is moved to this tile, its tape content will be read and accepted.",
"hilfe.aktoren.verwerfer": "Every empty tile will cancel the tokens run with a rejection of the current tape content.",
"hilfe.aktoren.befoerderer": "This actor is used for moving the token to neighbour tile without changing the tape content.",
"hilfe.aktoren.schreiber": "In order to write a symbol to the tape, this actor is utilized. The colour indicates which symbol will be written and the direction shows to which tile the token will be moved afterwards.",
"hilfe.aktoren.leser": "At a switch the first symbol of the tape will be read and the the token will be moved the the corresponding direction. If a matching way out exists, the symbol will be removed from the tape. If no way out matches or if the tape is empty the fallback exit (grey) will be chosen.",
"hilfe.aufgaben.einleitung": "The goal is to solve certain tasks. Two kind of tasks are distinguished:",
"hilfe.aufgaben.akzeptor.erklaerung": "Here the goal is to investigate the content of the tokens tape and to decide whether it fulfils a certain condition or not. IF so, the token shall be moved to the exit; otherwise to an arbitrary empty tile.",
"hilfe.aufgaben.akzeptor.beispiel": "Example: Accept then and only then, if the tape contains at least two red symbols.",
"hilfe.aufgaben.transduktor.erklaerung": "In a transductor task an output shall be generated, which has a certain relationship to to the input; in other words: to apply a function.",
"hilfe.aufgaben.transduktor.beispiel": "Example: The input repeated two times."
"key": "strings-en",
"value": {
"common.title": "Crazy Turing Machines",
"common.help": "Help",
"common.game": "Game",
"model.token.terms.singular": "token",
"model.token.terms.plural": "tokens",
"model.modes.initial": "edit machine",
"model.modes.uncertain": "testing …",
"model.modes.wrong": "flawed :/",
"model.modes.correct": "seemingly correct :)",
"model.actuators.terms.singular": "actor",
"model.actuators.terms.plural": "actors",
"model.actuators.kinds.erzeuger.name": "entrance",
"model.actuators.kinds.annehmer.name": "exit",
"model.actuators.kinds.verwerfer.name": "dropper",
"model.actuators.kinds.befoerderer.name": "conveyer",
"model.actuators.kinds.schreiber.name": "writer",
"model.actuators.kinds.leser.name": "switch",
"model.tasks.terms.singular": "task",
"model.tasks.terms.plural": "tasks",
"model.tasks.kinds.acceptor.name": "acceptor",
"model.tasks.kinds.acceptor.shortcut": "ACC",
"model.tasks.kinds.transductor.name": "transductor",
"model.tasks.kinds.transductor.shortcut": "TRA",
"controls.choose": "choose task",
"controls.step": "next step",
"controls.run": "run",
"controls.stop": "stop",
"controls.edit": "edit",
"controls.clear": "clear",
"help.introduction": "This game is inspired by !var:manufacturia, !var:crazy_machines, !var:world_of_goo … and also by memorable hours of the practical hardware course during computer science study :P",
"help.controls.title": "controls",
"help.controls.eintrag1": "left click/right click: change tile type",
"help.controls.eintrag2": "rotate mousewheel: rotate tile",
"help.token.satz1": "The token can be moved around the board by actors and it is displayed as a black circle.",
"help.token.satz2": "Additionally the token has a list of set symbols (its tape), which is shown as coloured points next to the token. The tape is always read at the front and written at its back (FIFO principle).",
"help.actuators.introduction": "Every tile on the board can be equipped with an actor, which will cause a certain effect on the token depending on the type. The following types are available:",
"help.actuators.erzeuger": "The entrance is statically placed on the most left tile of the board and is displayed as a white triangle. It is the spot at which the token is inserted into the board and moved to the indicated direction afterwards.",
"help.actuators.annehmer": "On the most right tile of the board the exit is statically placed; it is displayed as a white circle. If the token is moved to this tile, its tape content will be read and accepted.",
"help.actuators.verwerfer": "Every empty tile will cancel the tokens run with a rejection of the current tape content.",
"help.actuators.befoerderer": "This actor is used for moving the token to neighbour tile without changing the tape content.",
"help.actuators.schreiber": "In order to write a symbol to the tape, this actor is utilized. The colour indicates which symbol will be written and the direction shows to which tile the token will be moved afterwards.",
"help.actuators.leser": "At a switch the first symbol of the tape will be read and the the token will be moved the the corresponding direction. If a matching way out exists, the symbol will be removed from the tape. If no way out matches or if the tape is empty the fallback exit (grey) will be chosen.",
"help.tasks.introduction": "The goal is to solve certain tasks. Two kind of tasks are distinguished:",
"help.tasks.acceptor.description": "Here the goal is to investigate the content of the tokens tape and to decide whether it fulfils a certain condition or not. IF so, the token shall be moved to the exit; otherwise to an arbitrary empty tile.",
"help.tasks.acceptor.example": "Example: Accept then and only then, if the tape contains at least two red symbols.",
"help.tasks.transductor.description": "In a transductor task an output shall be generated, which has a certain relationship to to the input; in other words: to apply a function.",
"help.tasks.transductor.example": "Example: The input repeated two times."
}
}
);

120
quelldatein/haupt.ts
View file

@ -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");
if (lib_fehlermonade.voll(aufgaben_roh_))
let tasks_raw_ : lib_errormonade.type_errormonade<Array<any>> = mod_vtm.mod_data.read("tasks");
if (lib_errormonade.filled(tasks_raw_))
{
let aufgaben_roh : Array<any> = lib_fehlermonade.lesen(aufgaben_roh_);
let dom_auswahl : Element = document.querySelector("#aufgabe_auswahl");
aufgaben_roh.forEach
let tasks_raw : Array<any> = lib_errormonade.read(tasks_raw_);
let dom_selection : Element = document.querySelector("#task_selection");
tasks_raw.forEach
(
(aufgabe_roh, index) =>
(task_raw, index) =>
{
// Aufgabe registrieren
{
let aufgabe : mod_aufbau.mod_aufgabe.typ_aufgabe = mod_aufbau.mod_aufgabe.importieren(aufgabe_roh);
mod_aufbau.mod_aufgabe.registrieren(aufgabe);
let task : mod_model.mod_task.type_task = mod_model.mod_task.import_(task_raw);
mod_model.mod_task.registrieren(task);
}
// Option eintragen
// Option insert
{
let praefix : string = (
{
"akzeptor": lib_uebersetzung.holen("aufbau.aufgaben.arten.akzeptor.kuerzel"),
"transduktor": lib_uebersetzung.holen("aufbau.aufgaben.arten.transduktor.kuerzel"),
}[aufgabe_roh["art"]]
"acceptor": lib_translate.get("model.tasks.kinds.acceptor.shortcut"),
"transductor": lib_translate.get("model.tasks.kinds.transductor.shortcut"),
}[task_raw["kind"]]
);
let titel : string = ("[" + praefix + "]" + " " + aufgabe_roh["parameter"]["titel"]);
let titel : string = ("[" + praefix + "]" + " " + task_raw["parameter"]["titel"]);
let value : string = index.toFixed(0);
let dom_option : Element = document.createElement("option");
dom_option.setAttribute("value", value);
dom_option.textContent = titel;
dom_auswahl.appendChild(dom_option);
dom_selection.appendChild(dom_option);
}
}
)
;
dom_auswahl.addEventListener
dom_selection.addEventListener
(
"change",
event =>
{
let value : string = dom_auswahl["value"];
let value : string = dom_selection["value"];
let index : int = parseInt(value);
let aufgabe : mod_aufbau.mod_aufgabe.typ_aufgabe = mod_aufbau.mod_aufgabe.holen(index);
behandler(aufgabe);
let task : mod_model.mod_task.type_task = mod_model.mod_task.get(index);
behandler(task);
}
)
;
@ -79,25 +79,25 @@ module mod_vtm
/**
* @author kcf <vidofnir@folksprak.org>
*/
function haupt() : void
function main() : void
{
// Übersetzungen
{
let sprachen : Array<string> = navigator.languages.map(sprache => sprache);
let sprache_nativ : string = "de";
if (! sprachen[""+"includes"](sprache_nativ))
sprachen.push(sprache_nativ);
lib_uebersetzung.einrichten(sprachen);
lib_uebersetzung.anwenden(document);
let languages : Array<string> = navigator.languages.map(language => language);
let language_nativ : string = "de";
if (! languages[""+"includes"](language_nativ))
languages.push(language_nativ);
lib_translate.setup(languages);
lib_translate.deploy(document);
}
// Hilfe
{
// Einleitung
{
document.querySelector("#hilfe_einleitung").innerHTML = (
lib_uebersetzung.holen
document.querySelector("#help_introduction").innerHTML = (
lib_translate.get
(
"hilfe.einleitung",
"help.introduction",
{
"manufacturia": "<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"),
"bereich": document.querySelector("#hilfe_aktoren_aktor_erzeuger"),
"model": mod_model.mod_actuator.example("erzeuger"),
"bereich": document.querySelector("#help_actuators_actuator_erzeuger"),
},
{
"aufbau": mod_aufbau.mod_aktor.beispiel("annehmer"),
"bereich": document.querySelector("#hilfe_aktoren_aktor_annehmer"),
"model": mod_model.mod_actuator.example("annehmer"),
"bereich": document.querySelector("#help_actuators_actuator_annehmer"),
},
{
"aufbau": mod_aufbau.mod_aktor.beispiel("verwerfer"),
"bereich": document.querySelector("#hilfe_aktoren_aktor_verwerfer"),
"model": mod_model.mod_actuator.example("verwerfer"),
"bereich": document.querySelector("#help_actuators_actuator_verwerfer"),
},
{
"aufbau": mod_aufbau.mod_aktor.beispiel("befoerderer"),
"bereich": document.querySelector("#hilfe_aktoren_aktor_befoerderer"),
"model": mod_model.mod_actuator.example("befoerderer"),
"bereich": document.querySelector("#help_actuators_actuator_befoerderer"),
},
{
"aufbau": mod_aufbau.mod_aktor.beispiel("schreiber"),
"bereich": document.querySelector("#hilfe_aktoren_aktor_schreiber"),
"model": mod_model.mod_actuator.example("schreiber"),
"bereich": document.querySelector("#help_actuators_actuator_schreiber"),
},
{
"aufbau": mod_aufbau.mod_aktor.beispiel("leser"),
"bereich": document.querySelector("#hilfe_aktoren_aktor_leser"),
"model": mod_model.mod_actuator.example("leser"),
"bereich": document.querySelector("#help_actuators_actuator_leser"),
},
]
.forEach
@ -147,22 +147,22 @@ module mod_vtm
eintrag =>
{
let manifestation = (
mod_manifestation.mod_svg.mod_aktor.erstellen_manifestation
mod_manifestation.mod_svg.mod_actuator.create_manifestation
(
eintrag.aufbau,
mod_aufbau.mod_stelle.null_()
eintrag.model,
mod_model.mod_spot.null_()
)
);
let xmlknoten : lib_xml.typ_knoten = (
mod_manifestation.mod_svg.wurzel
let xmlnode : lib_xml.type_node = (
mod_manifestation.mod_svg.root
(
von_x, von_y,
bis_x, bis_y,
breite, hoehe,
[mod_manifestation.darstellen(manifestation)]
[mod_manifestation.view(manifestation)]
)
);
eintrag.bereich.querySelector(".hilfe_aktoren_aktor_bild").innerHTML = lib_xml.darstellen(xmlknoten);
eintrag.bereich.querySelector(".help_actuators_actuator_image").innerHTML = lib_xml.view(xmlnode);
}
)
;
@ -171,35 +171,35 @@ module mod_vtm
}
// Spiel
{
let partie : mod_aufbau.mod_partie.typ_partie;
let round : mod_model.mod_round.type_round;
// Aufgaben
{
aufgaben_eintragen
tasks_insert
(
function (aufgabe : mod_aufbau.mod_aufgabe.typ_aufgabe) : void {mod_aufbau.mod_partie.aufgabe_setzen(partie, aufgabe);}
function (task : mod_model.mod_task.type_task) : void {mod_model.mod_round.task_set(round, task);}
)
;
}
// Aufbau
{
partie = mod_aufbau.mod_partie.erstellen(mod_aufbau.mod_aufgabe.holen(0));
round = mod_model.mod_round.create(mod_model.mod_task.get(0));
}
// Manifestationen
{
[
mod_manifestation.mod_web.mod_partie.erstellen_erweitert
mod_manifestation.mod_web.mod_round.create_erweitert
(
partie,
document.querySelector("#bereich_mitte")
round,
document.querySelector("#section_mid")
)
,
mod_manifestation.mod_speicher.mod_partie.erstellen_erweitert
mod_manifestation.mod_store.mod_round.create_erweitert
(
partie
round
)
,
]
.forEach(mod_manifestation.einrichten);
.forEach(mod_manifestation.setup);
}
}
}
@ -208,12 +208,12 @@ module mod_vtm
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function eingang_web() : void
export function entry_web() : void
{
document.addEventListener
(
"DOMContentLoaded",
event => {haupt();}
event => {main();}
)
;
}

38
quelldatein/helfer/aufruf.ts
View file

@ -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>,
faelle : {[art : string] : (angaben ?: any)=>typ_ergebnis},
ersatz : (komplex : typ_komplex<any>)=>typ_ergebnis = ((komplex) => {throw (new Error("unbehandelt"));})
complex : type_complex<any>,
cases : {[kind : string] : (data ?: any)=>type_result},
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 ergebnis : typ_ergebnis = funktion(komplex.angaben);
return ergebnis;
let function_ : (data ?: any)=>type_result = cases[complex.kind];
let result : type_result = function_(complex.data);
return result;
}
else
{
let meldung : string = ("unbehandelte Art '" + komplex.art + "'");
console.warn(meldung);
let ergebnis : typ_ergebnis = ersatz(komplex);
return ergebnis;
let message : string = ("unbehandelte Art '" + complex.kind + "'");
console.warn(message);
let result : type_result = fallback(complex);
return result;
}
}
}

40
quelldatein/helfer/brauch.ts
View file

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

66
quelldatein/helfer/fehlermonade.ts
View file

@ -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,
"schlicht": ({"wert": wert}) => true,
"nothing": ({}) => false,
"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"));},
"schlicht": ({"wert": wert}) => wert,
"nothing": ({}) => {throw (new Error("read von nothing"));},
"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>,
funktion : (wert1 : typ_wert1)=>typ_fehlermonade<typ_wert2>
errormonade : type_errormonade<type_value1>,
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>(),
"schlicht": ({"wert": wert1}) => funktion(wert1),
"nothing": ({}) => create_nothing<type_value2>(),
"just": ({"value": value1}) => funktion(value1),
}
)
);

58
quelldatein/helfer/hashmap.ts
View file

@ -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;
speicher : {[hashwert : string] : {schluessel : typ_schluessel; wert : typ_wert;}};
hashfunction : (key : type_key)=>string;
store : {[hashvalue : string] : {key : type_key; value : type_value;}};
}
;
@ -33,15 +33,15 @@ module lib_hashmap
/**
* @author kcf <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>,
schluessel : typ_schluessel,
wert : typ_wert
hashmap : type_hashmap<type_key, type_value>,
key : type_key,
value : type_value
)
: void
{
let hashwert : string = hashmap.hashfunction(schluessel);
hashmap.speicher[hashwert] = {"schluessel": schluessel, "wert": wert};
let hashvalue : string = hashmap.hashfunction(key);
hashmap.store[hashvalue] = {"key": key, "value": value};
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function holen<typ_schluessel, typ_wert>
export function get<type_key, type_value>
(
hashmap : typ_hashmap<typ_schluessel, typ_wert>,
schluessel : typ_schluessel
hashmap : type_hashmap<type_key, type_value>,
key : type_key
)
: lib_fehlermonade.typ_fehlermonade<typ_wert>
: lib_errormonade.type_errormonade<type_value>
{
let hashwert : string = hashmap.hashfunction(schluessel);
if (hashwert in hashmap.speicher)
let hashvalue : string = hashmap.hashfunction(key);
if (hashvalue in hashmap.store)
{
let wert : typ_wert = hashmap.speicher[hashwert].wert;
return (lib_fehlermonade.erstellen_schlicht<typ_wert>(wert));
let value : type_value = hashmap.store[hashvalue].value;
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>,
prozedur : (schluessel ?: typ_schluessel, wert ?: typ_wert)=>void
hashmap : type_hashmap<type_key, type_value>,
procedure : (key ?: type_key, value ?: type_value)=>void
)
: void
{
Object.keys(hashmap.speicher).forEach
Object.keys(hashmap.store).forEach
(
(hashwert) =>
(hashvalue) =>
{
let paar : {schluessel : typ_schluessel; wert : typ_wert;} = hashmap.speicher[hashwert];
prozedur(paar.schluessel, paar.wert);
let paar : {key : type_key; value : type_value;} = hashmap.store[hashvalue];
procedure(paar.key, paar.value);
}
)
;

2
quelldatein/helfer/mathematik.ts
View file

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

100
quelldatein/helfer/uebersetzung.ts
View file

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

16
quelldatein/helfer/vektor.ts
View file

@ -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)};
}
}

6
quelldatein/helfer/verschiedenes.ts
View file

@ -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

88
quelldatein/helfer/xml.ts
View file

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

32
quelldatein/manifestation/manifestation.ts
View file

@ -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;
binden : (manifestation : typ_manifestation<typ_aufbau>)=>void;
view : (manifestation : type_manifestation<type_model>)=>type_ausgabe;
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);
binden<typ_aufbau, typ_ausgabe>(manifestation);
view<type_model, type_ausgabe>(manifestation);
bind<type_model, type_ausgabe>(manifestation);
}
}

14
quelldatein/manifestation/position.ts
View file

@ -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 basis2 : typ_position = lib_vektor.polar((2/6) * (2*Math.PI));
var basis1 : type_position = lib_vector.polar((0/6) * (2*Math.PI));
var basis2 : type_position = lib_vector.polar((2/6) * (2*Math.PI));
/**
* @author kcf <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_vektor.skalieren(basis2, stelle.v)
lib_vector.scale(basis1, spot.u),
lib_vector.scale(basis2, spot.v)
)
);
}

102
quelldatein/manifestation/speicher/partie.ts
View file

@ -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",
"angaben": erstellen(aufbau)
"kind": "store_round",
"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,
"aenderung_aufgabe",
(angaben) =>
round.model,
"aendrung_task",
(data) =>
{
// console.info("aenderung_aufgabe", angaben);
let aufgabe : mod_vtm.mod_aufbau.mod_aufgabe.typ_aufgabe = mod_vtm.mod_aufbau.mod_partie.aufgabe_lesen(partie.aufbau);
let id : string = mod_vtm.mod_aufbau.mod_aufgabe.id(aufgabe);
// console.info("aendrung_task", data);
let task : mod_vtm.mod_model.mod_task.type_task = mod_vtm.mod_model.mod_round.task_read(round.model);
let id : string = mod_vtm.mod_model.mod_task.id(task);
let key : string = ("vtm_" + id);
//
if (key in localStorage)
{
let item : string = localStorage.getItem(key);
let welt_ : any = JSON.parse(item);
let welt : mod_vtm.mod_aufbau.mod_welt.typ_welt = mod_vtm.mod_aufbau.mod_welt.importieren(welt_);
mod_vtm.mod_aufbau.mod_partie.welt_setzen(partie.aufbau, welt, false);
let world_ : any = JSON.parse(item);
let world : mod_vtm.mod_model.mod_world.type_world = mod_vtm.mod_model.mod_world.import_(world_);
mod_vtm.mod_model.mod_round.world_set(round.model, world, false);
}
else
{
mod_vtm.mod_aufbau.mod_partie.welt_leeren(partie.aufbau);
// nichts tun
mod_vtm.mod_model.mod_round.world_clear(round.model);
// nothing tun
}
}
)
;
mod_vtm.mod_aufbau.mod_partie.lauschen
mod_vtm.mod_model.mod_round.lauschen
(
partie.aufbau,
"aenderung_welt",
(angaben) =>
round.model,
"aendrung_world",
(data) =>
{
let aufgabe : mod_vtm.mod_aufbau.mod_aufgabe.typ_aufgabe = mod_vtm.mod_aufbau.mod_partie.aufgabe_lesen(partie.aufbau);
let id : string = mod_vtm.mod_aufbau.mod_aufgabe.id(aufgabe);
let task : mod_vtm.mod_model.mod_task.type_task = mod_vtm.mod_model.mod_round.task_read(round.model);
let id : string = mod_vtm.mod_model.mod_task.id(task);
let key : string = ("vtm_" + id);
//
let welt : mod_vtm.mod_aufbau.mod_welt.typ_welt = mod_vtm.mod_aufbau.mod_partie.welt_lesen(partie.aufbau);
let welt_ : any = mod_vtm.mod_aufbau.mod_welt.exportieren(welt);
let item : string = JSON.stringify(welt_);
let world : mod_vtm.mod_model.mod_world.type_world = mod_vtm.mod_model.mod_round.world_read(round.model);
let world_ : any = mod_vtm.mod_model.mod_world.export_(world);
let item : string = JSON.stringify(world_);
localStorage.setItem(key, item);
}
)
;
mod_vtm.mod_aufbau.mod_partie.lauschen
mod_vtm.mod_model.mod_round.lauschen
(
partie.aufbau,
"aenderung_figur",
(angaben) =>
round.model,
"aendrung_token",
(data) =>
{
// console.info("aenderung_figur", angaben);
// console.info("aendrung_token", data);
}
)
;
mod_vtm.mod_aufbau.mod_partie.lauschen
mod_vtm.mod_model.mod_round.lauschen
(
partie.aufbau,
"aenderung_modus",
(angaben) =>
round.model,
"aendrung_mode",
(data) =>
{
// console.info("aenderung_modus", angaben);
// console.info("aendrung_mode", data);
}
)
;
@ -151,13 +151,13 @@ module mod_vtm
/**
* @author kcf <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,
"speicher_partie",
trait_manifestation,
"store_round",
{
"darstellen": (manifestation) => darstellen(manifestation.angaben),
"binden": (manifestation) => binden(manifestation.angaben),
"view": (manifestation) => view(manifestation.data),
"bind": (manifestation) => bind(manifestation.data),
}
)
;

42
quelldatein/manifestation/svg/_svg.ts
View file

@ -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>,
schliessen : boolean = true,
attribute : {[schlussel : string] : string} = {},
vertices : Array<lib_vector.type_vector>,
close : boolean = true,
attributes : {[schlussel : string] : string} = {},
)
: lib_xml.typ_knoten
: lib_xml.type_node
{
let d : string = "";
vertices.forEach
@ -111,23 +111,23 @@ module mod_vtm
(vertex, index) =>
{
let c : string = ((index <= 0) ? "M" : "L");
let x : string = vertex.x.toFixed(float_praezission);
let y : string = vertex.y.toFixed(float_praezission);
let x : string = vertex.x.toFixed(float_precision);
let y : string = vertex.y.toFixed(float_precision);
d += [c, x, y].join(" ");
}
)
;
if (schliessen)
if (close)
d += "Z";
attribute["d"] = d;
return (lib_xml.erstellen_normal("path", attribute));
attributes["d"] = d;
return (lib_xml.create_normal("path", attributes));
}
/**
* @author kcf <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,
)
);
}

76
quelldatein/manifestation/svg/aktor/_aktor.ts
View file

@ -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;
stelle : mod_vtm.mod_aufbau.mod_stelle.typ_stelle;
model : mod_vtm.mod_model.mod_actuator.type_actuator;
spot : mod_vtm.mod_model.mod_spot.type_spot;
}
;
@ -58,16 +58,16 @@ module mod_vtm
/**
* @author kcf <vidofnir@folksprak.org>
*/
function erstellen
function create
(
aufbau : mod_vtm.mod_aufbau.mod_aktor.typ_aktor,
stelle : mod_vtm.mod_aufbau.mod_stelle.typ_stelle
model : mod_vtm.mod_model.mod_actuator.type_actuator,
spot : mod_vtm.mod_model.mod_spot.type_spot
)
: typ_aktor
: type_actuator
{
return {
"aufbau": aufbau,
"stelle": stelle
"model": model,
"spot": spot
};
}
@ -75,16 +75,16 @@ module mod_vtm
/**
* @author kcf <vidofnir@folksprak.org>
*/
export function erstellen_manifestation
export function create_manifestation
(
aufbau : mod_vtm.mod_aufbau.mod_aktor.typ_aktor,
stelle : mod_vtm.mod_aufbau.mod_stelle.typ_stelle
model : mod_vtm.mod_model.mod_actuator.type_actuator,
spot : mod_vtm.mod_model.mod_spot.type_spot
)
: typ_manifestation<mod_vtm.mod_aufbau.mod_aktor.typ_aktor>
: type_manifestation<mod_vtm.mod_model.mod_actuator.type_actuator>
{
return {
"art": "svg_aktor",
"angaben": erstellen(aufbau, stelle),
"kind": "svg_actuator",
"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 knoten_rahmen = function () : lib_xml.typ_knoten
let actuator : mod_vtm.mod_model.mod_actuator.type_actuator = actuator_.model;
let node_rahmen = function () : lib_xml.type_node
{
return (
pfad
path
(
mod_vtm.mod_helfer.sequenz(6).map(i => lib_vektor.polar(((i+0.5)/6) * (2*Math.PI), 0.5)),
mod_vtm.mod_helfer.sequence(6).map(i => lib_vector.polar(((i+0.5)/6) * (2*Math.PI), 0.5)),
true,
{
"class": "rahmen"
@ -109,30 +109,30 @@ module mod_vtm
);
}
;
let position : mod_position.typ_position = mod_position.von_stelle(aktor_.stelle);
let knoten_feld : lib_xml.typ_knoten = (
lib_xml.erstellen_normal
let position : mod_position.type_position = mod_position.von_spot(actuator_.spot);
let node_tile : lib_xml.type_node = (
lib_xml.create_normal
(
"g",
{
"class": "feld",
"rel": mod_vtm.mod_aufbau.mod_stelle.hash(aktor_.stelle),
"class": "tile",
"rel": mod_vtm.mod_model.mod_spot.hash(actuator_.spot),
"transform": translation(position.x, position.y),
},
(
[knoten_rahmen()]
.concat(lib_brauch.anwenden<signatur_aktor>(brauch_aktor, aktor.art)["darstellen"](aktor))
[node_rahmen()]
.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,
"svg_aktor",
trait_manifestation,
"svg_actuator",
{
"darstellen": (manifestation) => darstellen(manifestation.angaben),
"binden": (manifestation) => binden(manifestation.angaben),
"view": (manifestation) => view(manifestation.data),
"bind": (manifestation) => bind(manifestation.data),
}
)
;

24
quelldatein/manifestation/svg/aktor/annehmer.ts
View file

@ -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 knoten_kreis : lib_xml.typ_knoten = (
lib_xml.erstellen_normal
let children : Array<lib_xml.type_node> = [];
let node_kreis : lib_xml.type_node = (
lib_xml.create_normal
(
"circle",
{
"cx": (0.0).toFixed(float_praezission),
"cy": (0.0).toFixed(float_praezission),
"r": (0.25).toFixed(float_praezission),
"cx": (0.0).toFixed(float_precision),
"cy": (0.0).toFixed(float_precision),
"r": (0.25).toFixed(float_precision),
"class": (
[
"kreis",
@ -56,8 +56,8 @@ module mod_vtm
}
)
);
kinder.push(knoten_kreis);
return kinder;
children.push(node_kreis);
return children;
}
,
}

22
quelldatein/manifestation/svg/aktor/befoerderer.ts
View file

@ -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 knoten_pfeil : lib_xml.typ_knoten = (
lib_xml.erstellen_normal
let children : Array<lib_xml.type_node> = [];
let node_pfeil : lib_xml.type_node = (
lib_xml.create_normal
(
"path",
{
"d": form_pfeil,
"d": shape_arrow,
"class": (
[
"pfeil",
@ -53,7 +53,7 @@ module mod_vtm
),
"transform": (
[
rotation(richtung/6),
rotation(direction/6),
translation(-0.2, 0),
skalierung(0.12),
].join(" ")
@ -61,8 +61,8 @@ module mod_vtm
}
)
);
kinder.push(knoten_pfeil);
return kinder;
children.push(node_pfeil);
return children;
}
,
}

22
quelldatein/manifestation/svg/aktor/erzeuger.ts
View file

@ -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 knoten_pfeil : lib_xml.typ_knoten = (
lib_xml.erstellen_normal
let children : Array<lib_xml.type_node> = [];
let node_pfeil : lib_xml.type_node = (
lib_xml.create_normal
(
"path",
{
"d": form_pfeil,
"d": shape_arrow,
"class": (
[
"pfeil",
@ -53,7 +53,7 @@ module mod_vtm
),
"transform": (
[
rotation(richtung/6),
rotation(direction/6),
translation(-0.2, 0),
skalierung(0.12),
].join(" ")
@ -61,8 +61,8 @@ module mod_vtm
}
)
);
kinder.push(knoten_pfeil);
return kinder;
children.push(node_pfeil);
return children;
}
,
}

42
quelldatein/manifestation/svg/aktor/leser.ts
View file

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

22
quelldatein/manifestation/svg/aktor/schreiber.ts
View file

@ -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 knoten_pfeil : lib_xml.typ_knoten = (
lib_xml.erstellen_normal
let children : Array<lib_xml.type_node> = [];
let node_pfeil : lib_xml.type_node = (
lib_xml.create_normal
(
"path",
{
"d": form_pfeil,
"d": shape_arrow,
"class": (
[
"pfeil",
@ -53,7 +53,7 @@ module mod_vtm
),
"transform": (
[
rotation(richtung/6),
rotation(direction/6),
translation(-0.2, 0),
skalierung(0.12),
].join(" ")
@ -61,8 +61,8 @@ module mod_vtm
}
)
);
kinder.push(knoten_pfeil);
return kinder;
children.push(node_pfeil);
return children;
}
,
}

24
quelldatein/manifestation/svg/aktor/verwerfer.ts
View file

@ -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 knoten_kreis : lib_xml.typ_knoten = (
lib_xml.erstellen_normal
let children : Array<lib_xml.type_node> = [];
let node_kreis : lib_xml.type_node = (
lib_xml.create_normal
(
"circle",
{
"cx": (0.0).toFixed(float_praezission),
"cy": (0.0).toFixed(float_praezission),
"r": (0.25).toFixed(float_praezission),
"cx": (0.0).toFixed(float_precision),
"cy": (0.0).toFixed(float_precision),
"r": (0.25).toFixed(float_precision),
"class": (
[
"kreis",
@ -56,8 +56,8 @@ module mod_vtm
}
)
);
kinder.push(knoten_kreis);
return kinder;
children.push(node_kreis);
return children;
}
,
}

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

@ -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",
"angaben": erstellen(aufbau),
"kind": "svg_token",
"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 kinder_figur : Array<lib_xml.typ_knoten> = [];
let token : mod_vtm.mod_model.mod_token.type_token = token_.model;
let children_token : Array<lib_xml.type_node> = [];
// Stein
{
let knoten_stein : lib_xml.typ_knoten = (
lib_xml.erstellen_normal
let node_stein : lib_xml.type_node = (
lib_xml.create_normal
(
"circle",
{
"cx": (0.0).toFixed(float_praezission),
"cy": (0.0).toFixed(float_praezission),
"r": (0.125).toFixed(float_praezission),
"cx": (0.0).toFixed(float_precision),
"cy": (0.0).toFixed(float_precision),
"r": (0.125).toFixed(float_precision),
"class": "stein",
}
)
);
kinder_figur.push(knoten_stein);
children_token.push(node_stein);
}
// Band
{
let band : Array<mod_vtm.mod_aufbau.mod_symbol.typ_symbol> = mod_vtm.mod_aufbau.mod_figur.band_lesen(figur);
let kinder_band : Array<lib_xml.typ_knoten> = [];
band.forEach
let tape : Array<mod_vtm.mod_model.mod_symbol.type_symbol> = mod_vtm.mod_model.mod_token.tape_read(token);
let children_tape : Array<lib_xml.type_node> = [];
tape.forEach
(
(symbol, index) =>
{
let r : float = 0.06125;
let x : float = (+0.1+(2*r*1.25)*index);
let y : float = (-0.1);
let knoten_eintrag : lib_xml.typ_knoten = (
lib_xml.erstellen_normal
let node_eintrag : lib_xml.type_node = (
lib_xml.create_normal
(
"circle",
{
"cx": x.toFixed(float_praezission),
"cy": y.toFixed(float_praezission),
"r": r.toFixed(float_praezission),
"cx": x.toFixed(float_precision),
"cy": y.toFixed(float_precision),
"r": r.toFixed(float_precision),
/*
"x": (x-r).toFixed(float_praezission),
"y": (y-r).toFixed(float_praezission),
"width": (2*r).toFixed(float_praezission),
"height": (2*r).toFixed(float_praezission),
"x": (x-r).toFixed(float_precision),
"y": (y-r).toFixed(float_precision),
"width": (2*r).toFixed(float_precision),
"height": (2*r).toFixed(float_precision),
*/
"class": (
[
@ -130,42 +130,42 @@ module mod_vtm
}
)
);
kinder_band.push(knoten_eintrag);
children_tape.push(node_eintrag);
}
)
;
let knoten_band = (
lib_xml.erstellen_normal
let node_tape = (
lib_xml.create_normal
(
"g",
{
"class": "band",
"class": "tape",
},
kinder_band
children_tape
)
);
kinder_figur.push(knoten_band);
children_token.push(node_tape);
}
let position : mod_position.typ_position = mod_position.von_stelle(mod_vtm.mod_aufbau.mod_figur.stelle_lesen(figur));
let knoten_figur = (
lib_xml.erstellen_normal
let position : mod_position.type_position = mod_position.von_spot(mod_vtm.mod_model.mod_token.spot_read(token));
let node_token = (
lib_xml.create_normal
(
"g",
{
"class": "figur",
"class": "token",
"transform": translation(position.x, position.y),
},
kinder_figur
children_token
)
);
return knoten_figur;
return node_token;
}
/**
* @author kcf <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,
"svg_figur",
trait_manifestation,
"svg_token",
{
"darstellen": (manifestation) => darstellen(manifestation.angaben),
"binden": (manifestation) => binden(manifestation.angaben),
"view": (manifestation) => view(manifestation.data),
"bind": (manifestation) => bind(manifestation.data),
}
)
;

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

@ -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",
"angaben": erstellen(aufbau)
"kind": "svg_round",
"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> = [];
mod_vtm.mod_aufbau.mod_welt.felder_lesen(mod_vtm.mod_aufbau.mod_partie.welt_lesen(partie.aufbau)).forEach
let children_tiles : Array<lib_xml.type_node> = [];
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 knoten_feld : lib_xml.typ_knoten = mod_manifestation.darstellen(manifestation_feld);
kinder_felder.push(knoten_feld);
let manifestation_tile : type_manifestation<mod_vtm.mod_model.mod_actuator.type_actuator> = mod_actuator.create_manifestation(actuator, spot);
let node_tile : lib_xml.type_node = mod_manifestation.view(manifestation_tile);
children_tiles.push(node_tile);
}
)
;
let knoten_felder : lib_xml.typ_knoten = (
lib_xml.erstellen_normal
let node_tiles : lib_xml.type_node = (
lib_xml.create_normal
(
"g",
{
"class": "felder",
"class": "tiles",
},
kinder_felder
children_tiles
)
);
kinder_welt.push(knoten_felder);
children_world.push(node_tiles);
}
let knoten_welt : lib_xml.typ_knoten = (
lib_xml.erstellen_normal
let node_world : lib_xml.type_node = (
lib_xml.create_normal
(
"g",
{
"class": "welt",
"class": "world",
},
kinder_welt
children_world
)
);
kinder_partie.push(knoten_welt);
children_round.push(node_world);
}
// Figur
{
let figur_ : lib_fehlermonade.typ_fehlermonade<mod_vtm.mod_aufbau.mod_figur.typ_figur> = mod_vtm.mod_aufbau.mod_partie.figur_lesen(partie.aufbau);
if (lib_fehlermonade.voll(figur_))
let token_ : lib_errormonade.type_errormonade<mod_vtm.mod_model.mod_token.type_token> = mod_vtm.mod_model.mod_round.token_read(round.model);
if (lib_errormonade.filled(token_))
{
let figur : mod_vtm.mod_aufbau.mod_figur.typ_figur = lib_fehlermonade.lesen(figur_);
let manifestation_figur : typ_manifestation<mod_vtm.mod_aufbau.mod_figur.typ_figur> = mod_figur.erstellen_manifestation(figur);
let knoten_figur : lib_xml.typ_knoten = mod_manifestation.darstellen(manifestation_figur);
kinder_partie.push(knoten_figur);
let token : mod_vtm.mod_model.mod_token.type_token = lib_errormonade.read(token_);
let manifestation_token : type_manifestation<mod_vtm.mod_model.mod_token.type_token> = mod_token.create_manifestation(token);
let node_token : lib_xml.type_node = mod_manifestation.view(manifestation_token);
children_round.push(node_token);
}
else
{
// nichts tun
// nothing tun
}
}
let knoten_partie : lib_xml.typ_knoten = (
lib_xml.erstellen_normal
let node_round : lib_xml.type_node = (
lib_xml.create_normal
(
"g",
{
"class": "partie",
"class": "round",
},
kinder_partie
children_round
)
);
return knoten_partie;
return node_round;
}
/**
* @author kcf <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,
"svg_partie",
trait_manifestation,
"svg_round",
{
"darstellen": (manifestation) => darstellen(manifestation.angaben),
"binden": (manifestation) => binden(manifestation.angaben),
"view": (manifestation) => view(manifestation.data),
"bind": (manifestation) => bind(manifestation.data),
}
)
;

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

@ -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;
bereich : Element;
intervall : lib_fehlermonade.typ_fehlermonade<any>;
model : mod_model.mod_round.type_round;
area : Element;
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,
bereich : Element
model : mod_model.mod_round.type_round,
area : Element
)
: typ_partie
: type_round
{
return {
"aufbau": aufbau,
"bereich": bereich,
"intervall": (lib_fehlermonade.erstellen_nichts<any>()),
"model": model,
"area": area,
"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,
bereich : Element
model : mod_model.mod_round.type_round,
area : Element
)
: typ_manifestation<mod_aufbau.mod_partie.typ_partie>
: type_manifestation<mod_model.mod_round.type_round>
{
return {
"art": "web_partie",
"angaben": erstellen(aufbau, bereich)
"kind": "web_round",
"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 = (
text_nachbearbeiten
document.querySelector("#task_text").innerHTML = (
text_nachedit
(
mod_vtm.mod_aufbau.mod_aufgabe.text
mod_vtm.mod_model.mod_task.text
(
mod_vtm.mod_aufbau.mod_partie.aufgabe_lesen(partie.aufbau)
mod_vtm.mod_model.mod_round.task_read(round.model)
)
)
);
@ -105,103 +105,103 @@ module mod_vtm
/**
* @author kcf <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";
throw (new Error(meldung));
let message : string = "unbehandelter Modus";
throw (new Error(message));
break;
}
}
document.querySelector("#aufgabe_status").textContent = status;
document.querySelector("#task_status").textContent = status;
}
/**
* @author kcf <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)
? "ungewiss_laufend"
: "ungewiss_stehend"
lib_errormonade.filled<any>(round.intervall)
? "uncertain_running"
: "uncertain_standing"
);
break;
}
case mod_vtm.mod_aufbau.mod_modus.fehlerhaft:
case mod_vtm.mod_aufbau.mod_modus.korrekt:
case mod_vtm.mod_model.mod_mode.wrong:
case mod_vtm.mod_model.mod_mode.correct:
{
klasse = "fertig";
klasse = "done";
break;
}
default:
@ -210,164 +210,164 @@ module mod_vtm
break;
}
}
document.querySelector("#knoepfe").setAttribute("class", klasse);
document.querySelector("#buttons").setAttribute("class", klasse);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function darstellen(partie : typ_partie) : void
function view(round : type_round) : void
{
erneuern_aufgabe(partie);
erneuern_welt(partie);
erneuern_figur(partie);
erneuern_modus(partie);
erneuern_knoepfe(partie);
update_task(round);
update_world(round);
update_token(round);
update_mode(round);
update_buttons(round);
}
/**
* @author kcf <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));
partie.intervall = (lib_fehlermonade.erstellen_nichts<any>());
clearInterval(lib_errormonade.read(round.intervall));
round.intervall = (lib_errormonade.create_nothing<any>());
}
else
{
let meldung : string = "kein Intervall gesetzt";
console.warn(meldung);
let message : string = "kein Intervall gesetzt";
console.warn(message);
}
erneuern_knoepfe(partie);
update_buttons(round);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function fortfahren(partie : typ_partie) : void
function resume(round : type_round) : void
{
mod_vtm.mod_aufbau.mod_partie.fortfahren(partie.aufbau);
let modus : mod_vtm.mod_aufbau.mod_modus.typ_modus = mod_vtm.mod_aufbau.mod_partie.modus_lesen(partie.aufbau);
if (modus <= 1)
mod_vtm.mod_model.mod_round.resume(round.model);
let mode : mod_vtm.mod_model.mod_mode.type_mode = mod_vtm.mod_model.mod_round.mode_read(round.model);
if (mode <= 1)
{
// nichts tun
// nothing tun
}
else
{
anhalten(partie);
stop(round);
}
erneuern_knoepfe(partie);
update_buttons(round);
}
/**
* @author kcf <vidofnir@folksprak.org>
*/
function testen(partie : typ_partie) : void
function testen(round : type_round) : void
{
let handle : any = setInterval(() => fortfahren(partie), 500);
partie.intervall = (lib_fehlermonade.erstellen_schlicht<any>(handle));
let handle : any = setInterval(() => resume(round), 500);
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);
mod_vtm.mod_aufbau.mod_partie.zuruecksetzen(partie.aufbau);
stop(round);
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_aufbau.mod_partie.zuruecksetzen(partie.aufbau);
mod_vtm.mod_model.mod_round.world_clear(round.model);
mod_vtm.mod_model.mod_round.reset(round.model);
}
/**
* @author kcf <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 dom_feld : Element = target["closest"](".feld");
if (dom_feld == null)
let spot : lib_errormonade.type_errormonade<mod_vtm.mod_model.mod_spot.type_spot>;
let dom_tile : Element = target["closest"](".tile");
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")
stelle = (lib_fehlermonade.erstellen_schlicht<mod_vtm.mod_aufbau.mod_stelle.typ_stelle>(mod_vtm.mod_aufbau.mod_stelle.von_hash(rel)));
let rel : string = dom_tile.getAttribute("rel")
spot = (lib_errormonade.create_just<mod_vtm.mod_model.mod_spot.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,
"aenderung_aufgabe",
(angaben) =>
round.model,
"aendrung_task",
(data) =>
{
erneuern_aufgabe(partie);
update_task(round);
}
)
;
mod_vtm.mod_aufbau.mod_partie.lauschen
mod_vtm.mod_model.mod_round.lauschen
(
partie.aufbau,
"aenderung_welt",
(angaben) =>
round.model,
"aendrung_world",
(data) =>
{
erneuern_welt(partie);
update_world(round);
}
)
;
mod_vtm.mod_aufbau.mod_partie.lauschen
mod_vtm.mod_model.mod_round.lauschen
(
partie.aufbau,
"aenderung_figur",
(angaben) =>
round.model,
"aendrung_token",
(data) =>
{
erneuern_figur(partie);
update_token(round);
}
)
;
mod_vtm.mod_aufbau.mod_partie.lauschen
mod_vtm.mod_model.mod_round.lauschen
(
partie.aufbau,
"aenderung_modus",
(angaben) =>
round.model,
"aendrung_mode",
(data) =>
{
erneuern_modus(partie);
erneuern_knoepfe(partie);
update_mode(round);
update_buttons(round);
}
)
;
// Links-Klick
partie.bereich.addEventListener
round.area.addEventListener
(
"click",
event =>
{
event.preventDefault();
let stelle_ : lib_fehlermonade.typ_fehlermonade<mod_vtm.mod_aufbau.mod_stelle.typ_stelle> = stelle_ermitteln(event.target);
if (lib_fehlermonade.voll(stelle_))
let spot_ : lib_errormonade.type_errormonade<mod_vtm.mod_model.mod_spot.type_spot> = spot_ermitteln(event.target);
if (lib_errormonade.filled(spot_))
{
mod_vtm.mod_aufbau.mod_partie.welt_feld_wechseln(partie.aufbau, lib_fehlermonade.lesen(stelle_), false);
mod_vtm.mod_model.mod_round.world_tile_wechseln(round.model, lib_errormonade.read(spot_), false);
}
else
{
@ -377,16 +377,16 @@ module mod_vtm
)
;
// Rechts-Klick
partie.bereich.addEventListener
round.area.addEventListener
(
"contextmenu",
event =>
{
event.preventDefault();
let stelle_ : lib_fehlermonade.typ_fehlermonade<mod_vtm.mod_aufbau.mod_stelle.typ_stelle> = stelle_ermitteln(event.target);
if (lib_fehlermonade.voll(stelle_))
let spot_ : lib_errormonade.type_errormonade<mod_vtm.mod_model.mod_spot.type_spot> = spot_ermitteln(event.target);
if (lib_errormonade.filled(spot_))
{
mod_vtm.mod_aufbau.mod_partie.welt_feld_wechseln(partie.aufbau, lib_fehlermonade.lesen(stelle_), true);
mod_vtm.mod_model.mod_round.world_tile_wechseln(round.model, lib_errormonade.read(spot_), true);
}
else
{
@ -396,17 +396,17 @@ module mod_vtm
)
;
// Mausrad
partie.bereich.addEventListener
round.area.addEventListener
(
"wheel",
event =>
{
event.preventDefault();
let stelle_ : lib_fehlermonade.typ_fehlermonade<mod_vtm.mod_aufbau.mod_stelle.typ_stelle> = stelle_ermitteln(event.target);
if (lib_fehlermonade.voll(stelle_))
let spot_ : lib_errormonade.type_errormonade<mod_vtm.mod_model.mod_spot.type_spot> = spot_ermitteln(event.target);
if (lib_errormonade.filled(spot_))
{
let inkrement : int = ((event["deltaY"] < 0) ? -1 : +1);
mod_vtm.mod_aufbau.mod_partie.welt_feld_drehen(partie.aufbau, lib_fehlermonade.lesen(stelle_), inkrement);
mod_vtm.mod_model.mod_round.world_tile_rotate(round.model, lib_errormonade.read(spot_), inkrement);
}
else
{
@ -416,53 +416,53 @@ module mod_vtm
)
;
// Schritt
document.querySelector("#knopf_schritt").addEventListener
document.querySelector("#button_step").addEventListener
(
"click",
event =>
{
anhalten(partie);
fortfahren(partie);
stop(round);
resume(round);
}
)
;
// Testen
document.querySelector("#knopf_testen").addEventListener
document.querySelector("#button_test").addEventListener
(
"click",
event =>
{
testen(partie);
testen(round);
}
)
;
// Anhalten
document.querySelector("#knopf_anhalten").addEventListener
// stop
document.querySelector("#button_stop").addEventListener
(
"click",
event =>
{
anhalten(partie);
stop(round);
}
)
;
// Bearbeiten
document.querySelector("#knopf_bearbeiten").addEventListener
// edit
document.querySelector("#button_edit").addEventListener
(
"click",
event =>
{
bearbeiten(partie);
edit(round);
}
)
;
// Leeren
document.querySelector("#knopf_leeren").addEventListener
document.querySelector("#button_clear").addEventListener
(
"click",
event =>
{
leeren(partie);
clear(round);
}
)
;
@ -472,13 +472,13 @@ module mod_vtm
/**
* @author kcf <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,
"web_partie",
trait_manifestation,
"web_round",
{
"darstellen": (manifestation) => darstellen(manifestation.angaben),
"binden": (manifestation) => binden(manifestation.angaben),
"view": (manifestation) => view(manifestation.data),
"bind": (manifestation) => bind(manifestation.data),
}
)
;

132
quelldatein/manifestation/web/vtm.html
View file

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

86
quelldatein/manifestation/web/vtm.scss
View file

@ -63,32 +63,32 @@ body > header
margin: 8px;
}
#radio_hilfe,
#radio_spiel
#radio_help,
#radio_game
{
display: none;
}
#radio_hilfe:checked
#radio_help:checked
{
& ~ #hilfe {}
& ~ #spiel {display: none;}
& ~ #help {}
& ~ #game {display: none;}
}
#radio_spiel:checked
#radio_game:checked
{
& ~ #hilfe {display: none;}
& ~ #spiel {}
& ~ #help {display: none;}
& ~ #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 {}
& > #knopf_testen {}
& > #knopf_anhalten {display: none;}
& > #knopf_bearbeiten {display: none;}
& > #knopf_leeren {}
& > #button_step {}
& > #button_run {}
& > #button_stop {display: none;}
& > #button_edit {display: none;}
& > #button_clear {}
}
&.ungewiss_laufend
&.uncertain_running
{
& > #knopf_schritt {display: none;}
& > #knopf_testen {display: none;}
& > #knopf_anhalten {}
& > #knopf_bearbeiten {display: none;}
& > #knopf_leeren {display: none;}
& > #button_step {display: none;}
& > #button_run {display: none;}
& > #button_stop {}
& > #button_edit {display: none;}
& > #button_clear {display: none;}
}
&.ungewiss_stehend
&.uncertain_standing
{
& > #knopf_schritt {}
& > #knopf_testen {}
& > #knopf_anhalten {display: none;}
& > #knopf_bearbeiten {}
& > #knopf_leeren {display: none;}
& > #button_step {}
& > #button_run {}
& > #button_stop {display: none;}
& > #button_edit {}
& > #button_clear {display: none;}
}
&.fertig
&.done
{
& > #knopf_schritt {display: none;}
& > #knopf_testen {display: none;}
& > #knopf_anhalten {display: none;}
& > #knopf_bearbeiten {}
& > #knopf_leeren {display: none;}
& > #button_step {display: none;}
& > #button_run {display: none;}
& > #button_stop {display: none;}
& > #button_edit {}
& > #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;