347 lines
8.5 KiB
TypeScript
347 lines
8.5 KiB
TypeScript
/*
|
|
* 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": () => befoerderer_erstellen_aktor(0),
|
|
},
|
|
]
|
|
)
|
|
.concat
|
|
(
|
|
mod_vtm_helfer.sequenz(erweitert ? 4 : 2).map
|
|
(
|
|
symbol => (
|
|
{
|
|
"pruefer": (aktor) =>
|
|
{
|
|
if (aktor.art === "schreiber")
|
|
{
|
|
return (schreiber_symbol_lesen(aktor.angaben) === symbol);
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
,
|
|
"ersteller": () => schreiber_erstellen_aktor(0, 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 (
|
|
(leser_symbol_links_lesen(aktor.angaben) === symbol_links)
|
|
&&
|
|
(leser_symbol_rechts_lesen(aktor.angaben) === symbol_rechts)
|
|
);
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
,
|
|
"ersteller": () => leser_erstellen_aktor(0, symbol_links, symbol_rechts)
|
|
}
|
|
);
|
|
}
|
|
)
|
|
)
|
|
.concat
|
|
(
|
|
[
|
|
{
|
|
"pruefer": (aktor) => (aktor.art === "verwerfer"),
|
|
"ersteller": () => verwerfer_erstellen_aktor(),
|
|
},
|
|
]
|
|
)
|
|
);
|
|
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 = erzeuger_erstellen_aktor(0);
|
|
}
|
|
else if ((u === +groesse) && (v === 0))
|
|
{
|
|
aktor = annehmer_erstellen_aktor();
|
|
}
|
|
else
|
|
{
|
|
aktor = verwerfer_erstellen_aktor();
|
|
}
|
|
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
|
|
)
|
|
);
|
|
}
|
|
|
|
}
|
|
|