vojta@alfred
918 lines
27 KiB
JavaScript
918 lines
27 KiB
JavaScript
/*
|
||
* [Česky]
|
||
* Projekt: Robot Karel
|
||
* Copyright: Viz KOPIROVANI v kořenovém adresáři projektu
|
||
*
|
||
* [English]
|
||
* Project: Karel, the Robot
|
||
* Copyright: See COPYING in the top level directory
|
||
*/
|
||
|
||
// JavaScript - načítání, ukládání a export dat
|
||
|
||
// Příkazy a jejich indexy podle verze:
|
||
//
|
||
// Verze/Index Příkaz
|
||
// 1.0 1.1 1.2 2.0
|
||
// - - - 0 <prázdná řádka> (součást hlavičky)
|
||
// - - - 1 <komentář> (součást hlavičky)
|
||
// - - - 2 <název příkazu> (součást hlavičky)
|
||
// - - - 3 <prázdná řádka> (tělo příkazu)
|
||
// - - - 4 <komentář> (tělo příkazu)
|
||
// 0 0 0 5 KONEC, JINAK
|
||
// 1 1 1 6 KONEC
|
||
// 2 2 2 7 KDYŽ
|
||
// 3 3 3 8 DOKUD
|
||
// 4 4 4 9 OPAKUJ
|
||
// - 5 5 10 AŽ
|
||
// - - 6 11 RYCHLE
|
||
// - - 7 12 POMALU
|
||
// 5 6 8 13 STOP
|
||
// 6 7 9 14 KROK
|
||
// 7 8 10 15 VLEVO-VBOK
|
||
// 8 9 11 16 POLOŽ
|
||
// 9 10 12 17 ZVEDNI
|
||
//
|
||
// Poznámky k formátům níže:
|
||
//
|
||
// \t označuje znak <tabulátor>
|
||
// \n je pro znak <nová řádka>
|
||
//
|
||
// Formát ukládání (příkazy)
|
||
// =========================
|
||
//
|
||
// Karel<verze>\n
|
||
// P\n
|
||
// <index posledního příkazu>
|
||
// <jméno příkazu>\t<příkaz 1>,<příkaz 2>,...\n
|
||
// <jméno příkazu>\t<příkaz 1>,<příkaz 2>,...\n
|
||
// ...
|
||
// KONEC
|
||
//
|
||
// Takový řetězec se předá jako parametr funkci escape() a výsledná hodnota
|
||
// je poté nabídnuta k uložení.
|
||
//
|
||
// Formát příkazů:
|
||
//
|
||
// 1. Příkaz bez parametrů (<prázdná řádka>, <název příkazu>, KONEC, RYCHLE,
|
||
// POMALU, STOP, KROK, VLEVO-VBOK, POLOŽ, ZVEDNI a uživatelské příkazy
|
||
//
|
||
// <index příkazu>
|
||
//
|
||
// 2. Příkaz má parametr (KDYŽ, DOKUD, AŽ, OPAKUJ)
|
||
//
|
||
// (a) <index příkazu><mezera><podmínka KDYŽ, DOKUD, AŽ>
|
||
// (b) <index příkazu OPAKUJ><mezera><počet opakování OPAKUJ>
|
||
// (c) <index příkazu OPAKUJ>
|
||
//
|
||
// <podmínka> je následující:
|
||
//
|
||
// 1 ZEĎ -1 NENÍ ZEĎ
|
||
// 2 ZNAČKA -2 NENÍ ZNAČKA
|
||
// 3 DOMOV -3 NENÍ DOMOV
|
||
// 4 VÝCHOD -4 NENÍ VÝCHOD
|
||
// 5 SEVER -5 NENÍ SEVER
|
||
// 6 ZÁPAD -6 NENÍ ZÁPAD
|
||
// 7 JIH -7 NENÍ JIH
|
||
//
|
||
// <počet opakování OPAKUJ> je kladné číslo včetně nuly
|
||
//
|
||
// 3. Komentář
|
||
//
|
||
// <index příkazu><mezera><text upravený funkcí escape()>
|
||
//
|
||
// !! VAROVÁNÍ!!
|
||
//
|
||
// Od verze 1.1 se rozšířil repertoár o příkaz AŽ, proto při čtení verze
|
||
// 1.0 je nutno posunout <index příkazu> o 1, pokud je větší než 4.
|
||
//
|
||
// Od verze 1.2 přibyly příkazy RYCHLE a POMALU, proto je nutné při čtení
|
||
// verze 1.1 posunout <index příkazu> o 2, pokud je větší než 5.
|
||
//
|
||
// Od verze 2.0 se rozšířil slovník o komentáře a hlavičku, proto je nutné
|
||
// při čtení verze 1.2 posunout <index příkazu> vždy o 5.
|
||
//
|
||
// Verze 2.0 zavedla nový prvek 2.c), který byl v předchozích verzích
|
||
// ukládán s <počet opakování OPAKUJ> rovno -1 (minus jedné).
|
||
//
|
||
// Formát ukládání (město)
|
||
// =======================
|
||
//
|
||
// Karel<verze>\n
|
||
// M\n
|
||
// <pozice Karla X><mezera><pozice Karla Y>\n
|
||
// <směr natočení>\n
|
||
// <pozice domova X><mezera><pozice domova Y>\n
|
||
// <[0,9]><[0,8]>...<[0,0]>\n
|
||
// <[1,9]><[1,8]>...<[1,0]>\n
|
||
// ...
|
||
// <[9,9]><[9,8]>...<[9,0]>\n
|
||
// KONEC
|
||
//
|
||
// Takový řetězec se předá jako parametr funkci escape() a výsledná hodnota
|
||
// je poté nabídnuta k uložení.
|
||
//
|
||
// Formát políčka města <[x,y]>: číslo od 0 do 8 podle položených značek,
|
||
// nebo znak X, pokud je na daném políčku zeď.
|
||
//
|
||
// Město nemělo žádnou změnu od začátku vývoje, proto je <verze> rovna
|
||
// hodnotě "1.0" (bez uvozovek).
|
||
//
|
||
// Poznámka k souřadnicím:
|
||
//
|
||
// Pozice je vyjádřená jako dvojice [x,y], kde x a y je od 0 do 9. Symbol
|
||
// x označuje sloupec a symbol y řádku. Formát ukládání je tedy po sloupcích
|
||
// (první zapsaná textová řádka je rovna prvnímu sloupci města) shora dolů.
|
||
// Sloupcové ukládání vzniklo nejspíš omylem, ale už nebylo dále upravováno.
|
||
//
|
||
// Program Visual Karel 99 ukládá město po řádkách, takže zapsaná textová
|
||
// řádka odpovídá skutečné řádce města - to je velký rozdíl!
|
||
//
|
||
// Karel má na počátku pozici [0,0] (levý dolní roh), ale uživatelské
|
||
// rozhraní v tu dobu ukazuje souřadnici "1 × 1" (o jednu vyšší). Pravý dolní
|
||
// roh má pozici [9,0], v uživatelském rozhraní to je "10 × 1".
|
||
//
|
||
// Program Visual Karel 99 počítá pozici od jedné, ne od nuly, navíc počátek
|
||
// je vlevo nahoře. Levý horní roh je (1,1) (odpovídá pozici [0,9]), levý
|
||
// dolní roh má (1,10) (odpovídá umístění [0,0]), pravý dolní roh je (10,10)
|
||
// (odpovídá pozici [9,0]).
|
||
|
||
// ===========================================================================
|
||
// =~ Globální proměnné ~=====================================================
|
||
|
||
// Objekt pracující s daty
|
||
data = new Object();
|
||
|
||
// Načítací funkcionalita
|
||
data.nacitani = new Object();
|
||
|
||
// Ukládací funkcionalita
|
||
data.ukladani = new Object();
|
||
|
||
// Konstanty formatu
|
||
data.FORMAT_10 = 0;
|
||
data.FORMAT_11 = 1;
|
||
data.FORMAT_12 = 2;
|
||
data.FORMAT_20 = 3;
|
||
data.verze = [
|
||
{ retezec: "1.0", verze: prikazy.VERZE_10 },
|
||
{ retezec: "1.1", verze: prikazy.VERZE_11 },
|
||
{ retezec: "1.2", verze: prikazy.VERZE_12 },
|
||
{ retezec: "2.0", verze: prikazy.VERZE_20 }
|
||
];
|
||
|
||
// Typy zobrazovaného okna
|
||
data.typ = new Object();
|
||
data.typ.ULOZIT = "ulozit.html";
|
||
data.typ.EXPORT_MESTA = "export-mesto.html";
|
||
data.typ.EXPORT_SLOVNIKU = "export-slovnik.html";
|
||
|
||
// Značky
|
||
data.znacky = [ ".", "1", "2", "3", "4", "5", "6", "7", "8" ];
|
||
data.znacky[-1] = "X";
|
||
|
||
// ===========================================================================
|
||
// =~ Základní funkce pro ukládání a export města ~===========================
|
||
|
||
// Uložení do vnitřního formátu
|
||
data.ukladani.uloz_mesto = function ()
|
||
{
|
||
var uloz = "Karel1.0\nM\n";
|
||
uloz += karel.pozice.x + " " + (mesto.velikost.y - karel.pozice.y - 1) + "\n";
|
||
uloz += karel.smer + "\n";
|
||
uloz += domov.pozice.x + " " + (mesto.velikost.y - domov.pozice.y - 1) + "\n";
|
||
for ( var x = 0; x < mesto.velikost.x; x++ ) {
|
||
for ( var y = mesto.velikost.y-1; y >= 0; y-- ) {
|
||
uloz += data.znacky[mesto.pole[x][y]];
|
||
}
|
||
uloz += "\n";
|
||
}
|
||
uloz += "KONEC";
|
||
uloz = escape(uloz);
|
||
this.zobraz_v_okne(this.typ.NORMALNI, "uložení města", "<p>"+
|
||
"Následující text si pečlivě uschovejte. Neprovádějte na něm <i>ŽÁDNÉ</i> "+
|
||
"úpravy. Každá změna může způsobit jeho zpětnou nepoužitelnost. Nejlépe text "+
|
||
"označte, zkopírujte do schránky Windows (případně do schránky jiného "+
|
||
"systému) a vložte do prázdného souboru, např. v aplikaci Poznámkový blok "+
|
||
"(Notepad). Raději nepoužívejte programy, které provádí další formátování "+
|
||
"textu, tím by se mohl text znehodnotit."+
|
||
"</p>", uloz, 24);
|
||
}
|
||
|
||
// Export do formátu Visual Karel 99
|
||
data.ukladani.export_mesto_k99 = function ()
|
||
{
|
||
var uloz =
|
||
"Velikost města: " + mesto.velikost.x + ", " + mesto.velikost.y + "\n";
|
||
uloz += "Pozice Karla: " +
|
||
(karel.pozice.x+1) + ", " + (mesto.velikost.y-karel.pozice.y) + "\n";
|
||
uloz += "Otočení Karla: " + karel.nazev_smeru_plny[karel.smer] +"\n";
|
||
uloz += "Umístění domova: " +
|
||
(domov.pozice.x+1) + ", " + (mesto.velikost.y-domov.pozice.y) + "\n\n";
|
||
uloz += "Definice města:\n";
|
||
for ( var y = mesto.velikost.y-1; y >= 0; y-- ) {
|
||
for ( var x = 0; x < mesto.velikost.x; x++ ) {
|
||
uloz += data.znacky[mesto.pole[x][y]];
|
||
}
|
||
uloz += "\n";
|
||
}
|
||
uloz = uloz.slice( 0, -1 ); // Odstranit poslední ukončení řádky
|
||
this.zobraz_v_okne(this.typ.NORMALNI, "export města", "<p>"+
|
||
"Následující text je určen pro program Visual Karel 99. Nevím, jak jsou na "+
|
||
"tom konkurenční programy s formátem, proto nelze zaručit větší "+
|
||
"přenositelnost města."+
|
||
"</p><p>"+
|
||
"Symbol X označuje zeď, číslo nahrazuje počet položených značek a tečka značí "+
|
||
"prázdné pole. Na jednom poli nemůže být zároveď zeď a Karel, nebo Karlův "+
|
||
"domov. Na jednom poli také nemůže být víc jak 8 značek."+
|
||
"</p>", uloz, 23);
|
||
}
|
||
|
||
// ===========================================================================
|
||
// =~ Základní funkce pro ukládání a export slovníku ~========================
|
||
|
||
// Kontrola prázdného slovníku
|
||
data.ukladani.zkontroluj_slovnik = function ()
|
||
{
|
||
if ( prikazy.seznam[prikazy.seznam.length-1].systemovy ) {
|
||
alert( "Není co uložit. Slovník je prázdný." );
|
||
return false;
|
||
} else {
|
||
return true;
|
||
}
|
||
}
|
||
|
||
// Příprava slovníku na uložení
|
||
data.ukladani.priprav_slovnik = function (format)
|
||
{
|
||
var verze = data.verze[format].verze;
|
||
var index = 0;
|
||
for ( var i = 0; i < prikazy.seznam.length; i++ ) {
|
||
var prikaz = prikazy.seznam[i];
|
||
if ( prikaz.kompatibilita & prikaz.verze_ulozeni & verze ) {
|
||
prikaz.index = index;
|
||
index++;
|
||
} else {
|
||
delete prikaz.index;
|
||
}
|
||
}
|
||
}
|
||
|
||
// Formátování seznamu příkazů
|
||
data.ukladani.formatuj_text = function (objekt)
|
||
{
|
||
var text = "";
|
||
if ( objekt.ostatni.length ) {
|
||
text += objekt.ostatni.join( ", " );
|
||
}
|
||
if ( objekt.prikazy.length ) {
|
||
if ( text.length > 0 ) {
|
||
text += " a ";
|
||
}
|
||
if ( objekt.prikazy.length == 1 ) {
|
||
text += "příkaz ";
|
||
} else {
|
||
text += "příkazy ";
|
||
}
|
||
text += objekt.prikazy.join( ", " );
|
||
}
|
||
return text;
|
||
}
|
||
|
||
// Přidá jeden příkaz do seznamu špatných příkazů, nebo varování
|
||
data.ukladani.pridej_prikaz = function (objekt, prikaz)
|
||
{
|
||
if ( ! objekt.seznam[prikaz.jmeno] ) {
|
||
if ( prikaz.prikaz ) {
|
||
objekt.prikazy.push(prikaz.jmeno);
|
||
} else {
|
||
objekt.ostatni.push(prikaz.jmeno);
|
||
}
|
||
objekt.seznam[prikaz.jmeno] = true;
|
||
}
|
||
}
|
||
|
||
// Vrací true, pokud není seznam prázdný
|
||
data.ukladani.nastalo = function (objekt)
|
||
{
|
||
return (objekt.prikazy.length || objekt.ostatni.length);
|
||
}
|
||
|
||
// Kontrola verze slovníku
|
||
data.ukladani.zkontroluj_verze = function (format)
|
||
{
|
||
var verze = data.verze[format].verze;
|
||
var spatne = { seznam: {}, prikazy: [], ostatni: [] };
|
||
var varovani = { seznam: {}, prikazy: [], ostatni: [] };
|
||
var i = prikazy.seznam.length-1;
|
||
while ( i >= 0 && !prikazy.seznam[i].systemovy ) {
|
||
var prikaz = prikazy.seznam[i];
|
||
for ( var j = 0; j < prikaz.telo.length; j++ ) {
|
||
var radka = prikaz.telo[j];
|
||
if ( radka[0].verze_ulozeni & (~radka[0].kompatibilita) & verze ) {
|
||
// Příkaz nelze uložit
|
||
this.pridej_prikaz( spatne, radka[0] );
|
||
} else if ( !(radka[0].kompatibilita & verze) ) {
|
||
// Příkaz se neukládá
|
||
this.pridej_prikaz( varovani, radka[0] );
|
||
}
|
||
}
|
||
i--;
|
||
}
|
||
|
||
if ( this.nastalo(spatne) ) {
|
||
return { chyba: true, text: this.formatuj_text(spatne) };
|
||
} else if ( this.nastalo(varovani) ) {
|
||
return { varovani: true, text: this.formatuj_text(varovani) };
|
||
} else {
|
||
return {};
|
||
}
|
||
}
|
||
|
||
// Kontrola minimální verze slovníku
|
||
data.ukladani.zkontroluj_minimalni_format = function (format)
|
||
{
|
||
var novy_format = format-1;
|
||
while ( novy_format >= data.FORMAT_10 ) {
|
||
var test = this.zkontroluj_verze(novy_format);
|
||
if ( !test.chyba && !test.varovani ) {
|
||
format = novy_format;
|
||
} else {
|
||
break;
|
||
}
|
||
novy_format--;
|
||
}
|
||
return format;
|
||
}
|
||
|
||
// Provede uložení slovníku v daném formátu
|
||
data.ukladani.proved_ulozeni_prikazu = function (format, prikaz)
|
||
{
|
||
var verze = data.verze[format].verze;
|
||
var uloz = "";
|
||
if ( !prikaz.systemovy ) {
|
||
var radka_uloz = new Array();
|
||
for ( var i = 0; i < prikaz.telo.length; i++ ) {
|
||
var radka = prikaz.telo[i];
|
||
var prikaz_uloz;
|
||
// Pokud se má uložit (příkaz získal index z přípravy slovníku), ulož
|
||
if ( radka[0].index != undefined ) {
|
||
if ( radka[0].ukladac ) {
|
||
prikaz_uloz = radka[0].ukladac(verze, radka);
|
||
} else {
|
||
prikaz_uloz = this.obecny(verze, radka);
|
||
}
|
||
if ( prikaz_uloz ) {
|
||
radka_uloz.push(prikaz_uloz);
|
||
}
|
||
}
|
||
}
|
||
uloz = prikaz.jmeno + "\t" + radka_uloz.join(",") + "\n";
|
||
}
|
||
return uloz;
|
||
}
|
||
|
||
// Provede uložení slovníku
|
||
data.ukladani.proved_ulozeni_slovniku = function (format)
|
||
{
|
||
this.priprav_slovnik(format);
|
||
|
||
var uloz =
|
||
"Karel" + data.verze[format].retezec + "\n" +
|
||
"P\n" +
|
||
prikazy.seznam[prikazy.seznam.length-1].index + "\n";
|
||
for ( var i = 0; i < prikazy.seznam.length; i++ ) {
|
||
uloz += this.proved_ulozeni_prikazu(format, prikazy.seznam[i]);
|
||
}
|
||
uloz += "KONEC";
|
||
return escape(uloz);
|
||
}
|
||
|
||
// Ulož slovník v novém formátu
|
||
data.ukladani.uloz_slovnik = function (format)
|
||
{
|
||
if ( this.zkontroluj_slovnik() ) {
|
||
var navrat = this.zkontroluj_verze(format);
|
||
if ( navrat.chyba ) {
|
||
alert( "Chyba!\n\nSlovník nelze uložit ve formátu " +
|
||
data.verze[format].retezec +
|
||
", protože obsahuje " + navrat.text + "." );
|
||
} else {
|
||
if ( navrat.varovani ) {
|
||
if ( ! window.confirm(
|
||
"Varování!\n\nSlovník při ukládání do formátu " +
|
||
data.verze[format].retezec +
|
||
" nebude obsahovat " + navrat.text + ".\n\nPřesto uložit?" ) ) {
|
||
return;
|
||
}
|
||
} else {
|
||
// Najdi minimální verzi, ve které jde uložit příkaz
|
||
format = this.zkontroluj_minimalni_format(format);
|
||
}
|
||
|
||
var uloz = this.proved_ulozeni_slovniku(format);
|
||
this.zobraz_v_okne(this.typ.NORMALNI, "uložení slovníku", "<p>"+
|
||
"Následující text si pečlivě uschovejte. Neprovádějte na něm <i>ŽÁDNÉ</i> "+
|
||
"úpravy. Každá změna může způsobit jeho zpětnou nepoužitelnost. Nejlépe text "+
|
||
"označte, zkopírujte do schránky Windows (případně do schránky jiného "+
|
||
"systému) a vložte do prázdného souboru, např. v aplikaci Poznámkový blok "+
|
||
"(Notepad). Raději nepoužívejte programy, které provádí další formátování "+
|
||
"textu, tím by se mohl text znehodnotit."+
|
||
"</p>", uloz, 24);
|
||
}
|
||
}
|
||
}
|
||
|
||
data.ukladani.export_slovnik_k99 = function ()
|
||
{
|
||
if ( this.zkontroluj_slovnik() ) {
|
||
var format = new Array();
|
||
for ( var i = 0; i < prikazy.seznam.length; i++ ) {
|
||
var prikaz = prikazy.seznam[i];
|
||
if ( !prikaz.systemovy ) {
|
||
var obsah = new Obsah();
|
||
var vysledek = prikazy.formatovac.zformatuj_prikaz(prikaz, obsah);
|
||
format.push(obsah.obsah());
|
||
}
|
||
}
|
||
uloz = format.join("%0A%0A");
|
||
this.zobraz_v_okne(this.typ.KOMENTARE, "export slovníku", "<p>"+
|
||
"Následující text je určen pro program Visual Karel 99. Bez větších úprav ho "+
|
||
"jistě bude možno použít i v jiných (konkurenčních) programech zabývající se "+
|
||
"problematikou robota Karla."+
|
||
"</p>"+
|
||
"<p><b>Varování!</b> Pokud jste použili podmínku nebo opakování s příkazem "+
|
||
"AŽ, pak nebude v programu Visual Karel 99 fungovat, protože v něm tato "+
|
||
"vlastnost není naprogramována."+
|
||
"</p>", unescape(uloz), 21);
|
||
}
|
||
}
|
||
|
||
// ===========================================================================
|
||
// =~ Funkce pro ukládání a export jednotlivých příkazů ~=====================
|
||
|
||
// Obecné ukládání
|
||
data.ukladani.obecny = function (format, radka)
|
||
{
|
||
if ( radka[0].index != undefined ) {
|
||
if ( radka.length > 1 ) {
|
||
return radka[0].index + " " + radka.slice(1).join(" ");
|
||
} else {
|
||
return "" + radka[0].index;
|
||
}
|
||
} else {
|
||
return undefined;
|
||
}
|
||
}
|
||
|
||
// Cyklus
|
||
data.ukladani.uloz_OPAKUJ = function (format, radka)
|
||
{
|
||
var pocet = "";
|
||
if ( radka.length == 1 && format < data.FORMAT_20 ) {
|
||
pocet = " -1";
|
||
} else if ( radka.length == 2 ) {
|
||
pocet = " " + radka[1];
|
||
}
|
||
return radka[0].index + pocet;
|
||
}
|
||
|
||
// Komentář
|
||
data.ukladani.uloz_komentar = function (format, radka)
|
||
{
|
||
if ( format >= data.FORMAT_20 ) {
|
||
return radka[0].index + " " + escape(radka[1]);
|
||
} else {
|
||
return undefined;
|
||
}
|
||
}
|
||
|
||
// Název
|
||
data.ukladani.uloz_nazev = function (format, radka)
|
||
{
|
||
if ( format >= data.FORMAT_20 ) {
|
||
return radka[0].index;
|
||
} else {
|
||
return undefined;
|
||
}
|
||
}
|
||
|
||
// ===========================================================================
|
||
// =~ Základní funkce pro načítání ~==========================================
|
||
|
||
// Nahraj příkazy/město
|
||
data.nacitani.nacti = function ()
|
||
{
|
||
var hodnota = window.prompt(
|
||
"Vložte prosím text města nebo příkazů, který byl předtím vytvořen tímto " +
|
||
"Karlem. Jediná dlouhá řádka začíná slovem Karel a končí slovem KONEC.");
|
||
if ( hodnota && hodnota.length ) {
|
||
hodnota = hodnota.replace( /\s+/g, "" );
|
||
}
|
||
var vysledek = data.nacitani.proved_nacteni(hodnota);
|
||
vysledek.zobraz_chybu();
|
||
}
|
||
|
||
// Proveď nahrání příkazů/města
|
||
data.nacitani.proved_nacteni = function (hodnota)
|
||
{
|
||
var vysledek = new Vysledek();
|
||
// Základní kontroly
|
||
if ( hodnota && hodnota.length ) {
|
||
var radky = hodnota.split("%0A");
|
||
vysledek.chyba.formatuj - function (text) {
|
||
return text + "\n\nNemohu nehrát.";
|
||
}
|
||
vysledek.nastav( data.nacitani.kontrola_formatu(radky[0]) );
|
||
if ( vysledek.byla_chyba() ) return vysledek;
|
||
var format = vysledek.hodnota;
|
||
if ( radky[radky.length-1] != "KONEC" ) {
|
||
vysledek.nastav( new Chyba( true,
|
||
"Textová řádka není celá, nebo je poškozená." ) );
|
||
} else if ( radky.length < 4
|
||
|| radky.length > 2 && radky[1] != 'M' && radky[1] != 'P' ) {
|
||
vysledek.nastav( new Chyba( true,
|
||
"Nelze rozpoznat, zda se jedná o město nebo příkazy." ) );
|
||
} else if ( radky[1] == 'M' ) {
|
||
vysledek.chyba.formatuj = function (text) {
|
||
return text + "\n\nNemohu načíst město.";
|
||
}
|
||
vysledek.nastav( this.nacti_mesto(format, radky) );
|
||
if ( vysledek.je_hodnota() ) {
|
||
var hodnota = vysledek.hodnota;
|
||
mesto.nahraj_mesto( hodnota.karel, hodnota.smer, hodnota.domov,
|
||
hodnota.mesto );
|
||
}
|
||
} else {
|
||
vysledek.chyba.formatuj = function (text) {
|
||
return text + "\n\nNemohu načíst slovník.";
|
||
}
|
||
vysledek.nastav( this.nacti_slovnik(format, radky) );
|
||
if ( vysledek.je_hodnota() ) {
|
||
var hodnota = vysledek.hodnota;
|
||
prikazy.nahraj_slovnik( hodnota );
|
||
}
|
||
}
|
||
}
|
||
return vysledek;
|
||
}
|
||
|
||
// Kontrola verze
|
||
data.nacitani.kontrola_formatu = function (format)
|
||
{
|
||
format = unescape(format);
|
||
for ( var i = 0; i < data.verze.length; i++ ) {
|
||
if ( format == "Karel" + data.verze[i].retezec ) {
|
||
return new Vysledek( false, Vysledek.NIC, i );
|
||
}
|
||
}
|
||
ladici_vypis( CHYBA, "nacitani.kontrola_formatu", format,
|
||
"nerozpoznán formát" );
|
||
return new Vysledek( new Chyba( true,
|
||
"Neznámá verze " + format + "." ) );
|
||
}
|
||
|
||
// ===========================================================================
|
||
// =~ Základní funkce pro načítání města ~====================================
|
||
|
||
// Přečti pozici
|
||
data.nacitani.precti_pozici = function (radka, jmeno)
|
||
{
|
||
radka = radka.split( "%20" );
|
||
var x = parseInt(radka[0]);
|
||
var y = parseInt(radka[1]);
|
||
if ( radka.length == 2 && !isNaN(x) && !isNaN(y) ) {
|
||
if ( x >= 0 && x < mesto.velikost.x && y >= 0 && y < mesto.velikost.y ) {
|
||
return new Vysledek( false, Vysledek.NIC,
|
||
{ x: x, y: (mesto.velikost.y - y - 1) } );
|
||
} else {
|
||
return new Vysledek( new Chyba( true,
|
||
"Chybná pozice " + jmeno + "." ) );
|
||
}
|
||
} else {
|
||
return new Vysledek( new Chyba( true,
|
||
"Nerozpoznána pozice " + jmeno + "." ) );
|
||
}
|
||
}
|
||
|
||
// Přečti směr
|
||
data.nacitani.precti_smer = function (radka, jmeno)
|
||
{
|
||
var smer = parseInt(radka);
|
||
if ( !isNaN(smer) ) {
|
||
if ( smer >= 0 & smer < 4 ) {
|
||
return new Vysledek( false, Vysledek.NIC, smer );
|
||
} else {
|
||
return new Vysledek( new Chyba( true,
|
||
"Chybný směr natočení Karla." ) );
|
||
}
|
||
} else {
|
||
return new Vysledek( new Chyba( true,
|
||
"Nerozpoznán směr natočení Karla." ) );
|
||
}
|
||
}
|
||
|
||
// Přečti řádku města
|
||
data.nacitani.precti_radku_mesta = function (radka, pocet_radku)
|
||
{
|
||
if ( radka.length != pocet_radku ) {
|
||
return new Vysledek( new Chyba( true,
|
||
"Nebyly nalezeny všechny řádky města." ) );
|
||
}
|
||
var mesto_radka = new Array();
|
||
for ( var y = 0; y < pocet_radku; y++ ) {
|
||
var znak = radka.charAt(y);
|
||
for ( var i = -1; i < data.znacky.length; i++ ) {
|
||
if ( znak == data.znacky[i] ) {
|
||
mesto_radka[y] = i;
|
||
break;
|
||
}
|
||
}
|
||
if ( i == data.znacky.length ) {
|
||
return new Vysledek( new Chyba( true,
|
||
"Nerozpoznáno pole města." ) );
|
||
}
|
||
}
|
||
return new Vysledek( false, Vysledek.NIC, mesto_radka.reverse() );
|
||
}
|
||
|
||
// Načti město
|
||
data.nacitani.nacti_mesto = function (format, radky)
|
||
{
|
||
var vysledek = new Vysledek();
|
||
if ( format != data.FORMAT_10 ) {
|
||
vysledek.nastav( new Chyba( true,
|
||
"Bohužel neznám verzi " + data.verze[format].retezec + "." ) );
|
||
} else {
|
||
var velikost_mesta = { x: 10, y: 10 };
|
||
|
||
if ( radky.length != (velikost_mesta.y + 6) ) {
|
||
vysledek.nastav( new Chyba(true,
|
||
"Nebyly nalezeny všechny sloupce města." ) );
|
||
} else {
|
||
vysledek.nastav( this.precti_pozici(radky[2], "Karla") );
|
||
var karel_pozice = vysledek.hodnota;
|
||
vysledek.nastav( this.precti_smer(radky[3]) );
|
||
var smer = vysledek.hodnota;
|
||
vysledek.nastav( this.precti_pozici(radky[4], "domova") );
|
||
var domov_pozice = vysledek.hodnota;
|
||
var mesto_pole = new Array();
|
||
if ( !vysledek.byla_chyba() ) {
|
||
for ( var x = 0; x < velikost_mesta.x && !vysledek.byla_chyba(); x++ ) {
|
||
var nacteno = data.nacitani.precti_radku_mesta( radky[x+5],
|
||
velikost_mesta.y );
|
||
vysledek.nastav( nacteno );
|
||
mesto_pole[x] = vysledek.hodnota;
|
||
}
|
||
}
|
||
if ( !vysledek.byla_chyba() ) {
|
||
vysledek.nastav( false, Vysledek.NIC,
|
||
{ karel: karel_pozice,
|
||
smer: smer,
|
||
domov: domov_pozice,
|
||
mesto: mesto_pole } );
|
||
}
|
||
}
|
||
}
|
||
return vysledek;
|
||
}
|
||
|
||
// ===========================================================================
|
||
// =~ Základní funkce pro načítání slovníku ~=================================
|
||
|
||
// Načti slovník
|
||
data.nacitani.nacti_slovnik = function (format, radky)
|
||
{
|
||
var vysledek = new Vysledek();
|
||
var novy_slovnik = this.priprav_slovnik(format);
|
||
// Základní kontrola
|
||
if ( radky.length < 4
|
||
|| radky.length > 3 && (radky.length-4 != radky[2]-novy_slovnik.length+1)) {
|
||
vysledek.nastav( new Chyba( true,
|
||
"Slovník nejspíš není celý." ) );
|
||
} else {
|
||
var radky_slovniku = radky.slice(3, -1);
|
||
vysledek.nastav(
|
||
this.dekoduj_slovnik(format, radky_slovniku, novy_slovnik) );
|
||
}
|
||
return vysledek;
|
||
}
|
||
|
||
// Příprava slovníku na načtení
|
||
data.nacitani.priprav_slovnik = function (format)
|
||
{
|
||
var novy_slovnik = new Array();
|
||
var verze = data.verze[format].verze;
|
||
var slovnik = prikazy.seznam;
|
||
for ( var i = 0; i < slovnik.length && slovnik[i].systemovy; i++ ) {
|
||
var prikaz = slovnik[i];
|
||
if ( prikaz.kompatibilita & prikaz.verze_ulozeni & verze ) {
|
||
novy_slovnik.push( prikaz );
|
||
}
|
||
}
|
||
return novy_slovnik;
|
||
}
|
||
|
||
// Dekóduj slovník
|
||
data.nacitani.dekoduj_slovnik = function (format, radky_slovniku, novy_slovnik)
|
||
{
|
||
// Připrav prázdné příkazy
|
||
var vysledek = new Vysledek();
|
||
var start_index = novy_slovnik.length;
|
||
|
||
// Oddělit jednotlivé příkazy
|
||
vysledek.nastav( this.oddel_prikazy( radky_slovniku, novy_slovnik ) );
|
||
|
||
// Změna jmen
|
||
if ( !vysledek.byla_chyba() ) {
|
||
vysledek.nastav( this.oprav_nazvy( novy_slovnik ) );
|
||
}
|
||
|
||
// Načti příkazy
|
||
if ( !vysledek.byla_chyba() ) {
|
||
var i = start_index;
|
||
while ( i < novy_slovnik.length && !vysledek.byla_chyba() ) {
|
||
var novy_prikaz = novy_slovnik[i];
|
||
var radky_prikazu = novy_prikaz.kodovane_telo;
|
||
delete novy_prikaz.kodovane_telo;
|
||
vysledek.nastav(
|
||
this.dekoduj_prikaz(format, radky_prikazu, novy_prikaz, novy_slovnik) );
|
||
i++;
|
||
}
|
||
|
||
if ( !vysledek.byla_chyba() ) {
|
||
novy_slovnik = novy_slovnik.slice(start_index);
|
||
vysledek.nastav( false, Vysledek.NIC, novy_slovnik );
|
||
}
|
||
}
|
||
return vysledek;
|
||
}
|
||
|
||
// Odděl příkazy
|
||
data.nacitani.oddel_prikazy = function (radky_slovniku, slovnik)
|
||
{
|
||
for ( var i = 0; i < radky_slovniku.length; i++ ) {
|
||
var zaklad_prikazu = radky_slovniku[i].split("%09");
|
||
if ( zaklad_prikazu.length != 2 ) {
|
||
return new Vysledek( new Chyba( true,
|
||
"Nerozpoznán příkaz." ) );
|
||
}
|
||
var radky_prikazu = zaklad_prikazu[1].split("%2C");
|
||
var novy_prikaz = {
|
||
jmeno: unescape(zaklad_prikazu[0]),
|
||
telo: new Array(),
|
||
kodovane_telo: radky_prikazu
|
||
};
|
||
if ( !novy_prikaz.jmeno.length ) {
|
||
return new Vysledek( new Chyba( true,
|
||
"Nerozpoznán název příkazu." ) );
|
||
}
|
||
slovnik.push(novy_prikaz);
|
||
}
|
||
return new Vysledek();
|
||
}
|
||
|
||
// Oprav názvy
|
||
data.nacitani.oprav_nazvy = function (novy_slovnik)
|
||
{
|
||
for ( var i = 0; i < novy_slovnik.length; i++ ) {
|
||
var prikaz = novy_slovnik[i];
|
||
if ( !prikaz.systemovy ) {
|
||
var vysledek = new Vysledek();
|
||
vysledek.nastav(
|
||
prikazy.rozpoznavac.kontrola_jmena(prikaz.jmeno) );
|
||
if ( vysledek.byla_chyba() ) {
|
||
var nove_jmeno = this.najdi_nove_jmeno(prikaz.jmeno, novy_slovnik);
|
||
prikaz.jmeno = nove_jmeno;
|
||
vysledek.chyba.formatuj = function (text) {
|
||
return "Chyba při načítání slovníku: " + text +
|
||
"\n\nPříkaz byl přejmenován na " + nove_jmeno + ".";
|
||
}
|
||
vysledek.zobraz_chybu();
|
||
}
|
||
}
|
||
}
|
||
return new Vysledek();
|
||
}
|
||
|
||
// Najdi nové nekonfliktní jméno
|
||
data.nacitani.najdi_nove_jmeno = function (jmeno, slovnik)
|
||
{
|
||
var nove_jmeno;
|
||
var i = 1;
|
||
var spravne = false;
|
||
while ( !spravne ) {
|
||
spravne = true;
|
||
if ( i == 1 ) {
|
||
nove_jmeno = "!" + jmeno;
|
||
} else {
|
||
nove_jmeno = "!" + jmeno + " " + i;
|
||
}
|
||
for ( var j = slovnik.length-1; j >= 0 && !slovnik[j].systemovy; j-- ) {
|
||
if ( nove_jmeno == slovnik[j].jmeno ) {
|
||
spravne = false;
|
||
break;
|
||
}
|
||
}
|
||
i++;
|
||
}
|
||
return nove_jmeno;
|
||
}
|
||
|
||
// ===========================================================================
|
||
// =~ Funkce pro načítání jednotlivých příkazů ~==============================
|
||
|
||
// TODO: Podrobnější popis chyby v příkazu?
|
||
// Načtení příkazu
|
||
data.nacitani.dekoduj_prikaz = function (format, radky_prikazu, novy_prikaz,
|
||
novy_slovnik)
|
||
{
|
||
var vysledek = new Vysledek();
|
||
if ( format < data.FORMAT_20 ) {
|
||
novy_prikaz.telo.push( [ prikazy.NAZEV, novy_prikaz ] );
|
||
}
|
||
var i = 0;
|
||
while ( i < radky_prikazu.length && !vysledek.byla_chyba() ) {
|
||
var radka = radky_prikazu[i].split("%20");
|
||
var cislo = parseInt(radka[0]);
|
||
if ( isNaN(cislo) || cislo < 0 || cislo >= novy_slovnik.length ) {
|
||
vysledek.nastav( new Chyba( true,
|
||
"Při zpracování těla příkazu " + novy_prikaz.jmeno +
|
||
" nebyl rozpoznán příkaz." ) );
|
||
} else {
|
||
var novy_jeden_prikaz;
|
||
var prikaz = novy_slovnik[cislo];
|
||
radka[0] = prikaz;
|
||
for ( var j = 1; j < radka.length; j++ ) {
|
||
radka[j] = unescape(radka[j]);
|
||
}
|
||
if ( !prikaz.nacitac ) {
|
||
novy_jeden_prikaz = this.obecny(format, radka, novy_prikaz);
|
||
} else {
|
||
novy_jeden_prikaz = prikaz.nacitac(format, radka, novy_prikaz);
|
||
}
|
||
if ( novy_jeden_prikaz ) {
|
||
novy_prikaz.telo.push(novy_jeden_prikaz);
|
||
} else {
|
||
vysledek.nastav( new Chyba( true,
|
||
"Chybné parametry na řádce " + (i+1) + " v těle příkazu " +
|
||
novy_prikaz.jmeno + "." ) );
|
||
}
|
||
}
|
||
i++;
|
||
}
|
||
return vysledek;
|
||
}
|
||
|
||
// Obecné ukládání
|
||
data.nacitani.obecny = function (format, radka, novy_prikaz)
|
||
{
|
||
if ( radka.length != 1 ) {
|
||
return undefined;
|
||
} else {
|
||
return radka;
|
||
}
|
||
}
|
||
|
||
// Cyklus
|
||
data.nacitani.nacti_OPAKUJ = function (format, radka, novy_prikaz)
|
||
{
|
||
if ( radka.length > 2 ) return undefined;
|
||
else if ( radka.length == 2 ) {
|
||
var pocet = parseInt(radka[1]);
|
||
if ( isNaN(pocet) || pocet < -1 ) return undefined;
|
||
if ( pocet == -1 ) {
|
||
radka = [ radka[0] ];
|
||
}
|
||
}
|
||
return radka;
|
||
}
|
||
|
||
// Podmínka
|
||
data.nacitani.nacti_podminku = function (format, radka, novy_prikaz)
|
||
{
|
||
if ( radka.length != 2 ) return undefined;
|
||
var podminka = parseInt(radka[1]);
|
||
if ( isNaN(podminka) || podminka == 0
|
||
|| !isNaN(podminka) && Math.abs(podminka) > prikazy.podminky.length ) {
|
||
return undefined;
|
||
}
|
||
return radka;
|
||
}
|
||
|
||
// Komentář
|
||
data.nacitani.nacti_komentar = function (format, radka, novy_prikaz)
|
||
{
|
||
if ( radka.length != 2 ) return undefined;
|
||
radka[1] = unescape(radka[1]);
|
||
return radka;
|
||
}
|
||
|
||
// Název
|
||
data.nacitani.nacti_nazev = function (format, radka, novy_prikaz)
|
||
{
|
||
if ( radka.length != 1 ) return undefined;
|
||
radka[1] = novy_prikaz;
|
||
return radka;
|
||
}
|