vtm/quelldatein/manifestation/svg/partie.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 Public 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 Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

module mod_vtm
	{
		
		export module mod_manifestation
			{
				
				export module mod_svg
					{
						
						export module mod_partie
							{
								
								/**
								 * @author kcf <vidofnir@folksprak.org>
								 */
								export type typ_partie =
									{
										aufbau : mod_vtm.mod_aufbau.mod_partie.typ_partie;
									}
								;
								
								
								/**
								 * @author kcf <vidofnir@folksprak.org>
								 */
								function erstellen(aufbau : mod_vtm.mod_aufbau.mod_partie.typ_partie) : typ_partie
									{
										return {
											"aufbau": aufbau
										};
									}
								
								
								/**
								 * @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>
									{
										return {
											"art": "svg_partie",
											"angaben": erstellen(aufbau)
										};
									}
								
								
								/**
								 * @author kcf <vidofnir@folksprak.org>
								 */
								function darstellen(partie : typ_partie) : lib_xml.typ_knoten
									{
										let kinder_partie : Array<lib_xml.typ_knoten> = [];
										// Welt
										{
											let kinder_welt : Array<lib_xml.typ_knoten> = [];
											// 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
													(
														({"stelle": stelle, "aktor": aktor}) =>
															{
																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 knoten_felder : lib_xml.typ_knoten = (
													lib_xml.erstellen_normal
														(
															"g",
															{
																"class": "felder",
															},
															kinder_felder
														)
													
												);
												kinder_welt.push(knoten_felder);
											}
											let knoten_welt : lib_xml.typ_knoten = (
												lib_xml.erstellen_normal
													(
														"g",
														{
															"class": "welt",
														},
														kinder_welt
													)
											);
											kinder_partie.push(knoten_welt);
										}
										// 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 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);
												}
											else
												{
													// nichts tun
												}
										}
										let knoten_partie : lib_xml.typ_knoten = (
											lib_xml.erstellen_normal
												(
													"g",
													{
														"class": "partie",
													},
													kinder_partie
												)
										);
										return knoten_partie;
									}
								
								
								/**
								 * @author kcf <vidofnir@folksprak.org>
								 */
								function binden(partie : typ_partie) : void
									{
									}
								
								
								/**
								 * @author kcf <vidofnir@folksprak.org>
								 */
								implementierung_manifestation["svg_partie"] =
									{
										"darstellen": (manifestation) => darstellen(manifestation.angaben),
										"binden": (manifestation) => binden(manifestation.angaben),
									}
								;
								
							}
						
					}
				
			}
		
	}