443 lines
11 KiB
TypeScript
443 lines
11 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 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_model
|
|
{
|
|
|
|
export module mod_round
|
|
{
|
|
|
|
/**
|
|
* @author kcf <vidofnir@folksprak.org>
|
|
*/
|
|
export type type_round =
|
|
{
|
|
world : mod_world.type_world;
|
|
token : lib_errormonade.type_errormonade<mod_token.type_token>;
|
|
task : mod_task.type_task;
|
|
testindex : lib_errormonade.type_errormonade<int>;
|
|
mode : mod_mode.type_mode;
|
|
listeners : {[event : string] : Array<(data ?: any)=>void>};
|
|
}
|
|
;
|
|
|
|
|
|
/**
|
|
* @author kcf <vidofnir@folksprak.org>
|
|
*/
|
|
export function create
|
|
(
|
|
task : mod_task.type_task
|
|
)
|
|
: type_round
|
|
{
|
|
let round : type_round =
|
|
{
|
|
"world": undefined,
|
|
"token": undefined,
|
|
"task": task,
|
|
"testindex": undefined,
|
|
"mode": undefined,
|
|
"listeners": undefined,
|
|
}
|
|
;
|
|
round.listeners =
|
|
{
|
|
"aendrung_task": [],
|
|
"aendrung_world": [],
|
|
"aendrung_token": [],
|
|
"aendrung_mode": [],
|
|
}
|
|
;
|
|
world_clear(round, false);
|
|
reset(round, false);
|
|
return round;
|
|
}
|
|
|
|
|
|
/**
|
|
* @author kcf <vidofnir@folksprak.org>
|
|
*/
|
|
export function lauschen
|
|
(
|
|
round : type_round,
|
|
event : string,
|
|
procedure : (data ?: any)=>void
|
|
)
|
|
: void
|
|
{
|
|
if (event in round.listeners)
|
|
{
|
|
round.listeners[event].push(procedure);
|
|
}
|
|
else
|
|
{
|
|
let message : string = "kein Ereignis mit diesem Name";
|
|
throw (new Error(message));
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* @author kcf <vidofnir@folksprak.org>
|
|
*/
|
|
function notify
|
|
(
|
|
round : type_round,
|
|
event : string,
|
|
data : any = {}
|
|
) : void
|
|
{
|
|
if (event in round.listeners)
|
|
{
|
|
round.listeners[event].forEach
|
|
(
|
|
procedure =>
|
|
{
|
|
procedure(data);
|
|
}
|
|
)
|
|
;
|
|
}
|
|
else
|
|
{
|
|
let message : string = "kein Ereignis mit diesem Name";
|
|
throw (new Error(message));
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* @author kcf <vidofnir@folksprak.org>
|
|
*/
|
|
export function reset
|
|
(
|
|
round : type_round,
|
|
inform : boolean = true
|
|
)
|
|
: void
|
|
{
|
|
round.token = (lib_errormonade.create_nothing<mod_token.type_token>());
|
|
round.testindex = (lib_errormonade.create_nothing<int>());
|
|
round.mode = mod_mode.initial;
|
|
if (inform)
|
|
{
|
|
notify(round, "aendrung_token", {});
|
|
notify(round, "aendrung_mode", {});
|
|
}
|
|
else
|
|
{
|
|
// nothing tun
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* @author kcf <vidofnir@folksprak.org>
|
|
*/
|
|
export function task_read
|
|
(
|
|
round : type_round
|
|
)
|
|
: mod_task.type_task
|
|
{
|
|
return round.task;
|
|
}
|
|
|
|
|
|
/**
|
|
* @author kcf <vidofnir@folksprak.org>
|
|
*/
|
|
export function task_set
|
|
(
|
|
round : type_round,
|
|
task : mod_task.type_task
|
|
) : void
|
|
{
|
|
round.task = task;
|
|
// round.world_clear();
|
|
notify(round, "aendrung_task", {});
|
|
reset(round);
|
|
}
|
|
|
|
|
|
/**
|
|
* @author kcf <vidofnir@folksprak.org>
|
|
*/
|
|
export function world_read
|
|
(
|
|
round : type_round
|
|
)
|
|
: mod_world.type_world
|
|
{
|
|
return round.world;
|
|
}
|
|
|
|
|
|
/**
|
|
* @author kcf <vidofnir@folksprak.org>
|
|
*/
|
|
export function world_set
|
|
(
|
|
round : type_round,
|
|
world : mod_world.type_world,
|
|
inform : boolean = true
|
|
)
|
|
: void
|
|
{
|
|
round.world = world;
|
|
if (inform)
|
|
{
|
|
notify(round, "aendrung_world", {});
|
|
}
|
|
else
|
|
{
|
|
// nothing tun
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* @author kcf <vidofnir@folksprak.org>
|
|
*/
|
|
export function world_clear
|
|
(
|
|
round : type_round,
|
|
inform : boolean = true
|
|
)
|
|
: void
|
|
{
|
|
round.world = mod_world.blanko();
|
|
if (inform)
|
|
{
|
|
notify(round, "aendrung_world", {});
|
|
}
|
|
else
|
|
{
|
|
// nothing tun
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* @author kcf <vidofnir@folksprak.org>
|
|
*/
|
|
export function token_read
|
|
(
|
|
round : type_round
|
|
)
|
|
: lib_errormonade.type_errormonade<mod_token.type_token>
|
|
{
|
|
return round.token;
|
|
}
|
|
|
|
|
|
/**
|
|
* @author kcf <vidofnir@folksprak.org>
|
|
*/
|
|
export function mode_read
|
|
(
|
|
round : type_round
|
|
)
|
|
: mod_mode.type_mode
|
|
{
|
|
return round.mode;
|
|
}
|
|
|
|
|
|
/**
|
|
* @author kcf <vidofnir@folksprak.org>
|
|
*/
|
|
export function world_tile_wechseln
|
|
(
|
|
round : type_round,
|
|
spot : mod_spot.type_spot,
|
|
umgekehrt : boolean = false
|
|
)
|
|
: void
|
|
{
|
|
if (! (round.mode === mod_mode.initial))
|
|
{
|
|
let message : string = "gesperrt";
|
|
}
|
|
else
|
|
{
|
|
mod_world.tile_wechseln(round.world, spot, umgekehrt);
|
|
notify
|
|
(
|
|
round,
|
|
"aendrung_world",
|
|
{
|
|
"kind": "tile_wechseln",
|
|
"data":
|
|
{
|
|
"spot": spot,
|
|
"umgekehrt": umgekehrt,
|
|
"tile": mod_world.tile_get(round.world, spot),
|
|
}
|
|
}
|
|
)
|
|
;
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* @author kcf <vidofnir@folksprak.org>
|
|
*/
|
|
export function world_tile_rotate
|
|
(
|
|
round : type_round,
|
|
spot : mod_spot.type_spot,
|
|
inkrement : int = +1
|
|
)
|
|
: void
|
|
{
|
|
if (! (round.mode === mod_mode.initial))
|
|
{
|
|
let message : string = "gesperrt";
|
|
}
|
|
else
|
|
{
|
|
mod_world.tile_rotate(round.world, spot, inkrement);
|
|
notify(round, "aendrung_world", {});
|
|
}
|
|
}
|
|
|
|
|
|
/**
|
|
* @author kcf <vidofnir@folksprak.org>
|
|
*/
|
|
export function resume
|
|
(
|
|
round : type_round
|
|
)
|
|
: void
|
|
{
|
|
switch (round.mode)
|
|
{
|
|
case mod_mode.initial:
|
|
{
|
|
round.mode = mod_mode.uncertain;
|
|
round.testindex = (lib_errormonade.create_just<int>(0));
|
|
notify(round, "aendrung_mode", {});
|
|
break;
|
|
}
|
|
case mod_mode.uncertain:
|
|
{
|
|
if (! lib_errormonade.filled<mod_token.type_token>(round.token))
|
|
{
|
|
let test : mod_test.type_test = mod_task.tests(round.task)[lib_errormonade.read<int>(round.testindex)];
|
|
let tape : Array<mod_symbol.type_symbol> = mod_vtm.mod_helfer.list_copy<mod_symbol.type_symbol>(mod_test.input(test));
|
|
let spot : mod_spot.type_spot = mod_world.erzeuger_finden(round.world);
|
|
round.token = (
|
|
lib_errormonade.create_just<mod_token.type_token>
|
|
(
|
|
mod_token.create
|
|
(
|
|
tape,
|
|
spot
|
|
)
|
|
)
|
|
);
|
|
}
|
|
else
|
|
{
|
|
let token : mod_token.type_token = lib_errormonade.read<mod_token.type_token>(round.token);
|
|
let spot : mod_spot.type_spot = mod_token.spot_read(token);
|
|
let actuator_ : lib_errormonade.type_errormonade<mod_actuator.type_actuator> = mod_world.tile_get(round.world, spot);
|
|
let actuator : mod_actuator.type_actuator = (
|
|
lib_errormonade.filled<mod_actuator.type_actuator>(actuator_)
|
|
? lib_errormonade.read<mod_actuator.type_actuator>(actuator_)
|
|
: mod_actuator.mod_verwerfer.create_actuator()
|
|
);
|
|
mod_actuator.use(actuator, token);
|
|
let state : mod_state.type_state = mod_token.state_read(token);
|
|
if (state === mod_state.running)
|
|
{
|
|
// nothing tun
|
|
}
|
|
else if ((state === mod_state.accepted) || (state === mod_state.rejected))
|
|
{
|
|
let accepted : boolean = (state === mod_state.accepted);
|
|
let ausgabe : Array<mod_symbol.type_symbol> = mod_token.tape_read(token);
|
|
round.token = (lib_errormonade.create_nothing<mod_token.type_token>());
|
|
let testindex : int = lib_errormonade.read<int>(round.testindex);
|
|
let tests : Array<mod_test.type_test> = mod_task.tests(round.task);
|
|
let test : mod_test.type_test = tests[testindex];
|
|
if (! mod_test.pruefen(test, accepted, ausgabe))
|
|
{
|
|
round.mode = mod_mode.wrong;
|
|
notify(round, "aendrung_mode", {});
|
|
}
|
|
else
|
|
{
|
|
testindex += 1;
|
|
if (testindex < tests.length)
|
|
{
|
|
// nächsten Test auswählen
|
|
round.testindex = (lib_errormonade.create_just<int>(testindex));
|
|
}
|
|
else
|
|
{
|
|
// auf Modus "correct" wechseln
|
|
round.testindex = (lib_errormonade.create_nothing<int>());
|
|
round.mode = mod_mode.correct;
|
|
notify(round, "aendrung_mode", {});
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
let message : string = "unbehandelter Zustand";
|
|
throw (new Error(message));
|
|
}
|
|
}
|
|
notify(round, "aendrung_token", {});
|
|
break;
|
|
}
|
|
case mod_mode.wrong:
|
|
{
|
|
// nothing tun
|
|
break;
|
|
}
|
|
case mod_mode.correct:
|
|
{
|
|
// nothing tun
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
let message : string = "unbehandelter Modus";
|
|
throw (new Error(message));
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|