sicherung

quelldatein/aufbau/leser.ts

@@ -18,9 +18,23 @@ module mod_vtm_aufbau
 				/**
 				 * @author kcf <vidofnir@folksprak.org>
 				 */
-				public constructor(richtung : typ_richtung = 0)
+				private symbol_links : typ_symbol;
+				
+				
+				/**
+				 * @author kcf <vidofnir@folksprak.org>
+				 */
+				private symbol_rechts : typ_symbol;
+				
+				
+				/**
+				 * @author kcf <vidofnir@folksprak.org>
+				 */
+				public constructor(richtung : typ_richtung = 0, symbol_links : typ_symbol = 0, symbol_rechts : typ_symbol = 1)
 					{
 						this.richtung = richtung;
+						this.symbol_links = symbol_links;
+						this.symbol_rechts = symbol_rechts;
 					}
 				
 				
@@ -33,6 +47,24 @@ module mod_vtm_aufbau
 					}
 				
 				
+				/**
+				 * @author kcf <vidofnir@folksprak.org>
+				 */
+				public symbol_links_lesen() : typ_symbol
+					{
+						return this.symbol_links;
+					}
+				
+				
+				/**
+				 * @author kcf <vidofnir@folksprak.org>
+				 */
+				public symbol_rechts_lesen() : typ_symbol
+					{
+						return this.symbol_rechts;
+					}
+				
+				
 				/**
 				 * @author kcf <vidofnir@folksprak.org>
 				 * @implementation
@@ -55,24 +87,17 @@ module mod_vtm_aufbau
 							{
 								let symbol : typ_symbol = symbol_.lesen();
 								figur.schieben();
-								switch (symbol)
+								     if (symbol === this.symbol_links)
 									{
-										case 0:
+										summand = +2;
-											{
-												summand = +1;
-												break;
 									}
-										case 1:
+								else if (symbol === this.symbol_rechts)
 									{
-												summand = -1;
+										summand = -2;
-												break;
 									}
-										default:
+								else
 									{
-												let meldung : string = ("ungültiges Symbol '" + String(symbol) + "'");
+										summand = 0;
-												throw (new Error(meldung));
-												break;
-											}
 									}
 							}
 						else

quelldatein/aufbau/transduktor.ts

@@ -0,0 +1,16 @@
+
+module mod_vtm_aufbau
+	{
+		
+		/**
+		 * @author kcf <vidofnir@folksprak.org>
+		 */
+		export class klasse_transduktor
+			{
+			}
+		
+		
+
+		
+	}
+

quelldatein/aufbau/welt.ts

@@ -72,24 +72,77 @@ module mod_vtm_aufbau
 				 */
 				public feld_wechseln(stelle : typ_stelle) : void
 					{
-						let liste : Array<{pruefer : (aktor : schnittstelle_aktor)=>boolean; ersteller : ()=>schnittstelle_aktor;}> =
+						let liste : Array<{pruefer : (aktor : schnittstelle_aktor)=>boolean; ersteller : ()=>schnittstelle_aktor;}> = (
+							[]
+							.concat
+								(
 									[
 										{
 											"pruefer": (aktor) => (aktor instanceof klasse_befoerderer),
 											"ersteller": () => new klasse_befoerderer(),
 										},
+									]
+								)
+							.concat
+								(
+									mod_vtm_helfer.sequenz(4).map
+										(
+											symbol => (
 												{
-									"pruefer": (aktor) => ((aktor instanceof klasse_schreiber) && ((<klasse_schreiber>(aktor)).symbol_lesen() === 0)),
+													"pruefer": (aktor) =>
-									"ersteller": () => new klasse_schreiber(0, 0),
-								},
 														{
-									"pruefer": (aktor) => ((aktor instanceof klasse_schreiber) && ((<klasse_schreiber>(aktor)).symbol_lesen() === 1)),
+															if (aktor instanceof klasse_schreiber)
-									"ersteller": () => new klasse_schreiber(0, 1),
-								},
 																{
-									"pruefer": (aktor) => (aktor instanceof klasse_leser),
+																	let schreiber : klasse_schreiber = <klasse_schreiber>(aktor);
-									"ersteller": () => new klasse_leser(),
+																	return (schreiber.symbol_lesen() === symbol);
-								},
+																}
+															else
+																{
+																	return false;
+																}
+														}
+													,
+													"ersteller": () => new klasse_schreiber(0, symbol),
+												}
+											)
+										)
+								)
+							.concat
+								(
+									mod_vtm_helfer.sequenz(2).map
+										(
+											index =>
+												{
+													let symbol_links : typ_symbol = (2*index+0);
+													let symbol_rechts : typ_symbol = (2*index+1);
+													return (
+														{
+															"pruefer": (aktor) =>
+																{
+																	if (aktor instanceof klasse_leser)
+																		{
+																			let leser : klasse_leser = <klasse_leser>(aktor);
+																			return (
+																				(leser.symbol_links_lesen() === symbol_links)
+																				&&
+																				(leser.symbol_rechts_lesen() === symbol_rechts)
+																			);
+																		}
+																	else
+																		{
+																			return false;
+																		}
+																}
+															,
+															"ersteller": () => new klasse_leser(0, symbol_links, 2*index+1),
+														}
+													);
+												}
+										)
+								)
+							.concat
+								(
+									[
 										{
 											"pruefer": (aktor) => (aktor instanceof klasse_annehmer),
 											"ersteller": () => new klasse_annehmer(),
@@ -99,7 +152,8 @@ module mod_vtm_aufbau
 											"ersteller": () => new klasse_verwerfer(),
 										},
 									]
-						;
+								)
+						);
 						let index : int;
 						let aktor_alt_ : schnittstelle_fehlermonade<schnittstelle_aktor> = this.felder.holen(stelle);
 						if (aktor_alt_.ist_schlicht)

quelldatein/darstellung_steuerung/welt.css

@@ -22,12 +22,22 @@
 
 .symbol_0
 	{
-		fill: hsl(  0, 50%, 50%);
+		fill: hsl(000.0000000000000, 50%, 50%);
 	}
 
 .symbol_1
 	{
-		fill: hsl(120, 50%, 50%);
+		fill: hsl(222.4922359499621, 50%, 50%);
+	}
+
+.symbol_2
+	{
+		fill: hsl(084.9844718999243, 50%, 50%);
+	}
+
+.symbol_3
+	{
+		fill: hsl(307.4767078498864, 50%, 50%);
 	}
 
 .kreis
@@ -50,7 +60,10 @@
 
 .eintrag
 	{
+		/*
 		stroke: black;
 		stroke-width: 0.01;
+		 */
+		stroke: none;
 	}
 

quelldatein/darstellung_steuerung/welt.ts

@@ -122,12 +122,12 @@ module mod_vtm_darstellung_steuerung
 																"symbol": new klasse_nichts<mod_vtm_aufbau.typ_symbol>(),
 															},
 															{
-																"summand": +1,
+																"summand": +2,
-																"symbol": new klasse_schlicht<mod_vtm_aufbau.typ_symbol>(0),
+																"symbol": new klasse_schlicht<mod_vtm_aufbau.typ_symbol>(leser.symbol_links_lesen()),
 															},
 															{
-																"summand": -1,
+																"summand": -2,
-																"symbol": new klasse_schlicht<mod_vtm_aufbau.typ_symbol>(1),
+																"symbol": new klasse_schlicht<mod_vtm_aufbau.typ_symbol>(leser.symbol_rechts_lesen()),
 															},
 														]
 													;
@@ -278,22 +278,22 @@ module mod_vtm_darstellung_steuerung
 										(dummy, symbol, index) =>
 											{
 												let r : float = 0.06125;
-												let x : float = (+0.1+(2*r)*index);
+												let x : float = (+0.1+(2*r*1.25)*index);
 												let y : float = (-0.1);
 												let knoten_eintrag : mod_vtm_helfer.schnittstelle_xmlknoten = (
 													new mod_vtm_helfer.klasse_xmlknoten_normal
 														(
-															"rect",
+															"circle",
 															{
-																/*
 																"cx": x.toFixed(svg_float_praezission),
 																"cy": y.toFixed(svg_float_praezission),
 																"r": r.toFixed(svg_float_praezission),
-																 */
+																/*
 																"x": (x-r).toFixed(svg_float_praezission),
 																"y": (y-r).toFixed(svg_float_praezission),
 																"width": (2*r).toFixed(svg_float_praezission),
 																"height": (2*r).toFixed(svg_float_praezission),
+																 */
 																"class": (
 																	[
 																		"eintrag",

quelldatein/daten/aufgaben.json

@@ -0,0 +1,27 @@
+{
+	"blau_filter": [
+		{
+			"titel": "Blau-Filter",
+			"text": "aus der Eingabe alle roten Einträge beibehalten und alle blauen entfernen",
+			"tests": [
+				{
+					"eingabe": [0,0,0,1,0],
+					"ausgabe": [0,0,0,0],
+				},
+				{
+					"eingabe": [1,0,1,0,1],
+					"ausgabe": [0,0,0],
+				},
+				{
+					"eingabe": [1,1,1,1,0],
+					"ausgabe": [0],
+				},
+				{
+					"eingabe": [0,1,1,0,0,1,0,1,1,1,0,1,0,0,1,1,1,1,1,1,0,1,0,1],
+					"ausgabe": [0,0,0,0,0,0,0,0,0],
+				},
+			]
+		}
+	]
+}
+