vtm/quelldatein/aufbau/welt.ts

/*
 * Verrückte Turing-Maschinen — A turing complete game
 * Copyright (C) 2016 Christian Fraß <vidofnir@folksprak.org>
 * 
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General export function welt_License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General export function welt_License for more details.
 * 
 * You should have received a copy of the GNU General export function welt_License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

module mod_vtm_aufbau
	{
		
		/**
		 * @author kcf <vidofnir@folksprak.org>
		 */
		export type typ_welt =
			{
				felder : mod_vtm_helfer.klasse_hashmap<typ_stelle, typ_aktor>;
			}
		;
		

		/**
		 * @author kcf <vidofnir@folksprak.org>
		 */
		export function welt_erstellen
			(
				felder : mod_vtm_helfer.klasse_hashmap<typ_stelle, typ_aktor> = (new mod_vtm_helfer.klasse_hashmap<typ_stelle, typ_aktor>(stelle_hash))
			)
			: typ_welt
			{
				return {
					"felder": felder,
				};
			}
		
		
		/**
		 * @author kcf <vidofnir@folksprak.org>
		 */
		export function welt_felder_lesen(welt : typ_welt) : Array<{stelle : typ_stelle; aktor : typ_aktor;}>
			{
				let felder : Array<{stelle : typ_stelle; aktor : typ_aktor;}> = [];
				welt.felder.iterieren
					(
						(stelle, aktor) => felder.push({"stelle": stelle, "aktor": aktor})
					)
				;
				return felder;
			}
		
		
		/**
		 * @author kcf <vidofnir@folksprak.org>
		 */
		export function welt_feld_holen(welt : typ_welt, stelle : typ_stelle) : schnittstelle_fehlermonade<typ_aktor>
			{
				return welt.felder.holen(stelle);
			}
		
		
		/**
		 * @author kcf <vidofnir@folksprak.org>
		 */
		export function welt_feld_setzen(welt : typ_welt, stelle : typ_stelle, aktor : typ_aktor) : void
			{
				welt.felder.setzen(stelle, aktor);
			}
		
		
		/**
		 * @author kcf <vidofnir@folksprak.org>
		 */
		export function welt_feld_wechseln(welt : typ_welt, stelle : typ_stelle, umgekehrt : boolean = false) : void
			{
				let erweitert : boolean = true;
				let liste : Array<{pruefer : (aktor : typ_aktor)=>boolean; ersteller : ()=>typ_aktor;}> = (
					[]
					.concat
						(
							[
								{
									"pruefer": (aktor) => (aktor.art === "befoerderer"),
									"ersteller": () => aktor_erstellen("befoerderer"),
								},
							]
						)
					.concat
						(
							mod_vtm_helfer.sequenz(erweitert ? 4 : 2).map
								(
									symbol => (
										{
											"pruefer": (aktor) =>
												{
													if (aktor.art === "schreiber")
														{
															return (aktor_schreiber_symbol_lesen(aktor.angaben) === symbol);
														}
													else
														{
															return false;
														}
												}
											,
											"ersteller": () => aktor_erstellen("schreiber", {"richtung": 0, "symbol": symbol})
										}
									)
								)
						)
					.concat
						(
							mod_vtm_helfer.sequenz(erweitert ? 2 : 1).map
								(
									index =>
										{
											let symbol_links : typ_symbol = (2*index+0);
											let symbol_rechts : typ_symbol = (2*index+1);
											return (
												{
													"pruefer": (aktor) =>
														{
															if (aktor.art === "leser")
																{
																	return (
																		(aktor_leser_symbol_links_lesen(aktor.angaben) === symbol_links)
																		&&
																		(aktor_leser_symbol_links_lesen(aktor.angaben) === symbol_rechts)
																	);
																}
															else
																{
																	return false;
																}
														}
													,
													"ersteller": () => aktor_erstellen("leser", {"richtung": 0, "symbol_links": symbol_links, "symbol_rechts": (2*index+1)}),
												}
											);
										}
								)
						)
					.concat
						(
							[
								{
									"pruefer": (aktor) => (aktor.art === "verwerfer"),
									"ersteller": () => aktor_erstellen("verwerfer"),
								},
							]
						)
				);
				let index_alt : schnittstelle_fehlermonade<int>;
				let aktor_alt_ : schnittstelle_fehlermonade<typ_aktor> = welt.felder.holen(stelle);
				if (aktor_alt_.ist_schlicht)
					{
						let aktor_alt : typ_aktor = aktor_alt_.lesen();
						let gefunden : boolean = liste.some
							(
								(eintrag, index) =>
									{
										if (eintrag.pruefer(aktor_alt))
											{
												index_alt = (new klasse_schlicht<int>(index));
												return true;
											}
										else
											{
												return false;
											}
									}
							)
						;
						if (! gefunden)
							{
								index_alt = (new klasse_nichts<int>());
							}
						else
							{
								// nichts tun
							}
					}
				else
					{
						let meldung : string = "kein Aktor gesetzt";
						// console.warn(meldung);
						index_alt = (new klasse_schlicht<int>(0));
					}
				if (index_alt.ist_schlicht())
					{
						let index_neu : int = mod_vtm_helfer.mod(index_alt.lesen() + (umgekehrt ? -1 : +1), liste.length);
						let aktor_neu : typ_aktor = liste[index_neu].ersteller();
						welt_feld_setzen(welt, stelle, aktor_neu);
					}
				else
					{
						let meldung : string = ("Aktor nicht gefunden");
						// throw (new Error(meldung));
						console.warn(meldung);
					}
			}
		
		
		/**
		 * @author kcf <vidofnir@folksprak.org>
		 */
		export function welt_feld_drehen(welt : typ_welt, stelle : typ_stelle, inkrement : int = +1) : void
			{
				let aktor_ : schnittstelle_fehlermonade<typ_aktor> = welt.felder.holen(stelle);
				if (aktor_.ist_schlicht)
					{
						aktor_drehen(aktor_.lesen(), inkrement);
					}
				else
					{
						console.warn("kein Aktor gesetzt");
					}
			}
		

		/**
		 * @author kcf <vidofnir@folksprak.org>
		 * @throws {Error}
		 */
		export function welt_erzeuger_finden(welt : typ_welt) : typ_stelle
			{
				let stelle : schnittstelle_fehlermonade<typ_stelle> = (new klasse_nichts<typ_stelle>());
				welt.felder.iterieren
					(
						(stelle_, aktor) =>
							{
								if (aktor.art === "erzeuger")
									{
										if (stelle.ist_schlicht())
											{
												let meldung : string = "mehrere Erzeuger gefunden";
												throw (new Error(meldung));
											}
										else
											{
												stelle = (new klasse_schlicht<typ_stelle>(stelle_));
											}
									}
							}
					)
				;
				if (stelle.ist_schlicht())
					{
						return stelle.lesen();
					}
				else
					{
						let meldung : string = "kein Erzeuger gefunden";
						throw (new Error(meldung));
					}
			}
		
		
		/**
		 * @author kcf <vidofnir@folksprak.org>
		 */
		export function welt_blanko(groesse : int = 3) : typ_welt
			{
				let welt : typ_welt = welt_erstellen();
				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};
										let aktor : typ_aktor;
										    if ((u === -groesse) && (v === 0))
											{
												aktor = aktor_erstellen("erzeuger", {"richtung": 0});
											}
										else if ((u === +groesse) && (v === 0))
											{
												aktor = aktor_erstellen("annehmer", {});
											}
										else
											{
												aktor = aktor_erstellen("verwerfer", {});
											}
										welt.felder.setzen(stelle, aktor);
									}
							}
					}
				return welt;
			}
		
		
		/**
		 * @author kcf <vidofnir@folksprak.org>
		 */
		export function welt_exportieren(welt : typ_welt) : any
			{
				let roh : any = {};
				roh["felder"] = {};
				welt.felder.iterieren
					(
						(stelle, aktor) =>
							{
								let stelle_ : string = stelle_exportieren(stelle);
								let aktor_ : any = aktor_exportieren(aktor);
								roh["felder"][stelle_] = aktor_;
							}
					)
				;
				return roh;
			}
		
		
		/**
		 * @author kcf <vidofnir@folksprak.org>
		 */
		export function welt_importieren(roh : any) : typ_welt
			{
				let felder : mod_vtm_helfer.klasse_hashmap<typ_stelle, typ_aktor> = (new mod_vtm_helfer.klasse_hashmap<typ_stelle, typ_aktor>(stelle_hash));
				for (let stelle_ in roh["felder"])
					{
						let stelle : typ_stelle = stelle_importieren(stelle_);
						let aktor_ : typ_aktor = roh["felder"][stelle_];
						let aktor : typ_aktor = aktor_importieren(aktor_);
						felder.setzen(stelle, aktor);
					}
				return (
					welt_erstellen
						(
							felder
						)
				);
			}
		
	}