vtm/quelldatein/aufbau/welt.ts

module mod_vtm_aufbau
	{
		
		/**
		 * @author kcf <vidofnir@folksprak.org>
		 */
		export class klasse_welt
			{
				
				/**
				 * @author kcf <vidofnir@folksprak.org>
				 */
				private felder : mod_vtm_helfer.klasse_hashmap<typ_stelle, schnittstelle_aktor>;
				
				
				/**
				 * @author kcf <vidofnir@folksprak.org>
				 */
				private figur : klasse_figur;
				
				
				/**
				 * @author kcf <vidofnir@folksprak.org>
				 */
				public constructor
					(
						felder : mod_vtm_helfer.klasse_hashmap<typ_stelle, schnittstelle_aktor> = new mod_vtm_helfer.klasse_hashmap<typ_stelle, schnittstelle_aktor>(stelle_hash),
						figur : klasse_figur = new klasse_figur()
					)
					{
						this.felder = felder;
						this.figur = figur;
					}
				
				
				/**
				 * @author kcf <vidofnir@folksprak.org>
				 */
				public felder_lesen() : Array<{stelle : typ_stelle; aktor : schnittstelle_aktor;}>
					{
						let felder : Array<{stelle : typ_stelle; aktor : schnittstelle_aktor;}> = [];
						this.felder.iterieren
							(
								(stelle, aktor) => felder.push({"stelle": stelle, "aktor": aktor})
							)
						;
						return felder;
					}
				
				
				/**
				 * @author kcf <vidofnir@folksprak.org>
				 */
				public figur_lesen() : klasse_figur
					{
						return this.figur;
					}
				
				
				/**
				 * @author kcf <vidofnir@folksprak.org>
				 */
				public feld_setzen(stelle : typ_stelle, aktor : schnittstelle_aktor) : void
					{
						this.felder.setzen(stelle, aktor);
					}
				
				
				/**
				 * @author kcf <vidofnir@folksprak.org>
				 */
				public feld_wechseln(stelle : typ_stelle) : void
					{
						let liste : Array<{pruefer : (aktor : schnittstelle_aktor)=>boolean; ersteller : ()=>schnittstelle_aktor;}> =
							[
								{
									"pruefer": (aktor) => (aktor instanceof klasse_befoerderer),
									"ersteller": () => new klasse_befoerderer(),
								},
								{
									"pruefer": (aktor) => ((aktor instanceof klasse_schreiber) && ((<klasse_schreiber>(aktor)).symbol_lesen() === 0)),
									"ersteller": () => new klasse_schreiber(0, 0),
								},
								{
									"pruefer": (aktor) => ((aktor instanceof klasse_schreiber) && ((<klasse_schreiber>(aktor)).symbol_lesen() === 1)),
									"ersteller": () => new klasse_schreiber(0, 1),
								},
								{
									"pruefer": (aktor) => (aktor instanceof klasse_leser),
									"ersteller": () => new klasse_leser(),
								},
								{
									"pruefer": (aktor) => (aktor instanceof klasse_annehmer),
									"ersteller": () => new klasse_annehmer(),
								},
								{
									"pruefer": (aktor) => (aktor instanceof klasse_verwerfer),
									"ersteller": () => new klasse_verwerfer(),
								},
							]
						;
						let index : int;
						let aktor_alt_ : schnittstelle_fehlermonade<schnittstelle_aktor> = this.felder.holen(stelle);
						if (aktor_alt_.ist_schlicht)
							{
								let aktor_alt : schnittstelle_aktor = aktor_alt_.lesen();
								let gefunden : boolean = liste.some
									(
										(eintrag, index_) =>
											{
												if (eintrag.pruefer(aktor_alt))
													{
														index = index_;
														return true;
													}
												else
													{
														return false;
													}
											}
									)
								;
								if (! gefunden)
									{
										let meldung : string = ("Aktor nicht gefunden");
										throw (new Error(meldung));
									}
								else
									{
										// alles prima
									}
							}
						else
							{
								let meldung : string = "kein Aktor gesetzt";
								// console.warn(meldung);
								index = 0;
							}
						let aktor_neu : schnittstelle_aktor = liste[mod_vtm_helfer.mod(index+1, liste.length)].ersteller();
						this.feld_setzen(stelle, aktor_neu);
					}
				
				
				/**
				 * @author kcf <vidofnir@folksprak.org>
				 */
				public feld_drehen(stelle : typ_stelle) : void
					{
						let aktor_ : schnittstelle_fehlermonade<schnittstelle_aktor> = this.felder.holen(stelle);
						if (aktor_.ist_schlicht)
							{
								aktor_.lesen().drehen();
							}
						else
							{
								console.warn("kein Aktor gesetzt");
							}
					}
				
				
				/**
				 * @author kcf <vidofnir@folksprak.org>
				 */
				public fortfahren() : boolean
					{
						let stelle : typ_stelle = this.figur.stelle_lesen();
						let aktor_ : schnittstelle_fehlermonade<schnittstelle_aktor> = this.felder.holen(stelle);
						let aktor : schnittstelle_aktor = (aktor_.ist_schlicht() ? aktor_.lesen() : (new klasse_verwerfer()));
						aktor.verwenden(this.figur);
						let zustand : typ_zustand = this.figur.zustand_lesen();
						let ergebnis : boolean;
						switch (zustand)
							{
								case zustand_tot:
									{
										console.info("-- tot");
										ergebnis = false;
										break;
									}
								case zustand_normal:
									{
										// console.info("-- normal");
										ergebnis = true;
										break;
									}
								case zustand_fertig:
									{
										console.info("-- fertig");
										ergebnis = false;
										break;
									}
								default:
									{
										let meldung : string = "unbehandelter Zustand";
										throw (new Error(meldung));
										break;
									}
							}
						return ergebnis;
					}
				
				
				/**
				 * @author kcf <vidofnir@folksprak.org>
				 */
				public static blanko(groesse : int = 3) : klasse_welt
					{
						let welt : klasse_welt = new klasse_welt();
						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 : typ_stelle = {"u": u, "v": v};
												welt.felder.setzen(stelle, new klasse_verwerfer());
											}
									}
							}
						return welt;
					}
			}
		
	}