home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / spezial / 19 / wesp / wespedit.pas < prev   
Encoding:
Pascal/Delphi Source File  |  1990-08-02  |  17.8 KB  |  632 lines
  1. (* ====================================================== *)
  2. (*                   WESP +   Leveleditor                 *)
  3. (*            (C) 1990  Gerald Arend & toolbox            *)
  4. (*              Compiler: Turbo Pascal ab 5.0             *)
  5. (* ====================================================== *)
  6.  
  7. PROGRAM WespEdit;
  8. {$A+,B-,D-,E-,F-,I-,L-,N-,O-,R-,S-,V-}
  9.  
  10. USES Crt, Graph, Masktur4, WespEd, WespEd2;
  11. { Achtung: Die Screens/Eingabemasken wurden mit dem Programm "MaskEdit Plus"
  12.   vom DMV-Verlag erstellt. Aus lizenzrechtlichen Gründen ist die Weitergabe
  13.   der Unit "Masktur4" daher nur in compilierter Form als "MASKTUR4.TPU"
  14.   gestattet. }
  15.  
  16. CONST
  17.   AnzMaxRaeume = 99;
  18.   FileName: Str80 = 'WESP.LEV';
  19.  
  20. TYPE
  21.   DatenRec = RECORD                                    { Daten im Byte-Format }
  22.                Zeile: ARRAY[1..8] OF BYTE;
  23.                x, y  : BYTE;
  24.              END;
  25.   DatenArray = RECORD                    { alle Level im Bit-kodierten Format }
  26.                  Kennung: STRING[10];
  27.                  Level: ARRAY[1..AnzMaxRaeume] OF DatenRec; { Level im Byte-Format }
  28.                END;
  29.   LevelRec = RECORD                                  { Entschlüsseltes Format }
  30.                Feld: ARRAY[1..8, 1..8] OF BOOLEAN;
  31.                x, y:  BYTE;
  32.              END;
  33.  
  34. VAR
  35.   Datei: FILE OF DatenArray;
  36.   Daten: DatenArray;
  37.   Level: LevelRec;
  38.   Gd, Gm, i: INTEGER;
  39.   Info1, Info2, Info3, Info4,
  40.   NormInfo3, NormInfo4,
  41.   WeiterInfo4, LeerInfo, Zwischenwort: Str80;
  42.   LevelNr1, LevelNr2: BYTE;
  43.   ch: CHAR;
  44.   Fertig, ShowMenuNeu: BOOLEAN;
  45.   Auswahl: BYTE;
  46.   RundenStr: STRING[2];
  47.   IOFehler, OK: BOOLEAN;
  48.  
  49. CONST
  50.   Leerraum: DatenRec = (Zeile: ($00, $00, $00, $00, $00, $00, $00, $00);
  51.                         x: 0; y: 0);
  52.  
  53. PROCEDURE Pause;
  54. VAR
  55.   ch: CHAR;
  56. BEGIN
  57.   ch := ReadKey;
  58.   IF ch=#0 THEN
  59.     ch := ReadKey;
  60. END;
  61.  
  62. PROCEDURE IOTest;           { Testet nach IO-Fehlern und gibt evtl. Nachricht }
  63. VAR
  64.   IOCode: INTEGER;
  65.   FehlerStr: STRING[4];
  66. BEGIN
  67.   IOCode := IOResult;
  68.   IOFehler := (IOCode<>0);
  69.   CASE IOCode OF
  70.     2:   Info3:='Datei nicht gefunden';
  71.     3:   Info3:='Pfad nicht gefunden';
  72.     5:   Info3:='Zugriff verweigert';
  73.     6:   Info3:='Ungültige Kanalnummer';
  74.     8:   Info3:='Nicht genug Speicher';
  75.     10:  Info3:='Ungültiges Environment';
  76.     11:  Info3:='Ungültiges Format';
  77.     150: Info3:='Diskette ist schreibgeschützt';
  78.     152: Info4:='Laufwerk nicht bereit';
  79.   ELSE
  80.     Str(IOCode:4, FehlerStr);
  81.     Info3:='Allgemeiner I/O-Fehler Nr. '+FehlerStr;
  82.   END;
  83.   IF IOFehler THEN
  84.   BEGIN
  85.     Write(^G);
  86.     AlleFelderAusgabe;
  87.     Info4 := 'Operation nicht ausgeführt!';
  88.     MainMenu(Auswahl, FileName, Info1, Info2, LevelNr1,
  89.              ZwischenWort, LevelNr2, Info3, Info4, FALSE);
  90.     Pause;
  91.   END;
  92. END;
  93.  
  94. PROCEDURE LoadRunden;                           { Alle Level auf einmal laden }
  95. BEGIN
  96.   {$I-}
  97.   Assign(Datei, FileName);
  98.   IOTest;
  99.   IF IOFehler THEN
  100.     Exit;
  101.   Reset(Datei);
  102.   IOTest;
  103.   IF IOFehler THEN
  104.     Exit;
  105.   Read(Datei, Daten);
  106.   IOTest;
  107.   IF IOFehler THEN
  108.     Exit;
  109.   Close(Datei);
  110.   {$I+}
  111. END;
  112.  
  113. PROCEDURE SaveRunden;                     { alle Level auf einmal abspeichern }
  114. CONST                                     { - es sind ja nur 1000 Bytes!      }
  115.   LevelKennung: STRING[10] = 'WESP plus*';
  116. BEGIN
  117.   {$I-}
  118.   AlleFelderAusgabe;
  119.   Info1 := 'RUNDEN SPEICHERN';
  120.   Info2 := 'Nach ' + FileName;
  121.   Info3 := '';
  122.   Info4 := 'Bitte etwas Geduld...';
  123.   MainMenu(Auswahl, FileName, Info1, Info2, LevelNr1,
  124.            ZwischenWort, LevelNr2, Info3, Info4, FALSE);
  125.   Daten.Kennung:=LevelKennung;
  126.   Assign(Datei, FileName);
  127.   IOTest;
  128.   IF IOFehler THEN
  129.     Exit;
  130.   Rewrite(Datei);
  131.   IOTest;
  132.   IF IOFehler THEN
  133.     Exit;
  134.   Write(Datei, Daten);
  135.   IOTest;
  136.   IF IOFehler THEN
  137.     Exit;
  138.   Close(Datei);
  139.   {$I+}
  140. END;
  141.  
  142. PROCEDURE FILE2Level(Raum: BYTE);                       { Level entschlüsseln }
  143. CONST
  144.   Wert: ARRAY[1..8] OF BYTE=(128, 64, 32, 16, 8, 4, 2, 1);
  145. VAR
  146.   x, y: INTEGER;
  147. BEGIN
  148.   Level.x := Daten.Level[Raum].x;                                   { Startposition }
  149.   Level.y := Daten.Level[Raum].y;
  150.   FOR x := 1 TO 8 DO
  151.     FOR y := 1 TO 8 DO
  152.       Level.Feld[y, x] := ((Daten.Level[Raum].Zeile[x] AND Wert[y]) > 0);
  153. END;
  154.  
  155. PROCEDURE Level2FILE(Raum: BYTE);                       { Level verschlüsseln }
  156. CONST
  157.   Wert: ARRAY[1..8] OF BYTE=(128, 64, 32, 16, 8, 4, 2, 1);
  158. VAR
  159.   x, y: INTEGER;
  160. BEGIN
  161.   FOR x := 1 TO 8 DO
  162.   BEGIN
  163.     Daten.Level[Raum].Zeile[x] := 0;
  164.     FOR y := 1 TO 8 DO
  165.       IF Level.Feld[y, x] THEN
  166.         Daten.Level[Raum].Zeile[x] := Daten.Level[Raum].Zeile[x] OR Wert[y];
  167.   END;
  168.   Daten.Level[Raum].x := Level.x;                                   { Startposition }
  169.   Daten.Level[Raum].y := Level.y;
  170. END;
  171.  
  172. PROCEDURE ShowFlaeche(x, y: BYTE; CursorSetzen: BOOLEAN);{ Eine Fläche zeigen }
  173. CONST
  174.   Links = 13;
  175.   Oben =  13;
  176. BEGIN
  177.   GotoXY(Links + Pred(x) * 3, Oben + Pred(y));
  178.   IF Level.Feld[x, y] THEN
  179.   BEGIN
  180.     IF (Level.x=x) AND (Level.y=y) THEN
  181.       Write('**')
  182.     ELSE
  183.       Write('■■')
  184.   END
  185.   ELSE
  186.     Write('∙∙');
  187.   IF CursorSetzen THEN                         { Cursor evtl. auf Feld setzen }
  188.     GotoXY(Links + Pred(x) * 3, Oben + Pred(y));
  189. END;
  190.  
  191. PROCEDURE ShowRaum;                        { Alle Flächen eines Levels zeigen }
  192. VAR
  193.   x, y: BYTE;
  194. BEGIN
  195.   EditorScreen(FileName, LevelNr1, TRUE);
  196.   FOR x := 1 TO 8 DO
  197.     FOR y := 1 TO 8 DO
  198.       ShowFlaeche(x, y, FALSE);
  199. END;
  200.  
  201. PROCEDURE EditRaum(MitEingabe: BOOLEAN);                    { Level Editieren }
  202.   PROCEDURE Editieren;                                       { Editierroutine }
  203.     PROCEDURE ClearFeld;                               { Alle Flächen löschen }
  204.     VAR
  205.       x, y: BYTE;
  206.     BEGIN
  207.       Level.x := 1;
  208.       Level.y := 1;
  209.       FOR x := 1 TO 8 DO
  210.         FOR y := 1 TO 8 DO
  211.         BEGIN
  212.           Level.Feld[x, y] := FALSE;
  213.           ShowFlaeche(x, y, FALSE);
  214.         END;
  215.     END;
  216.  
  217.     PROCEDURE Zufall;                                { Zufallslevel erstellen }
  218.     TYPE
  219.       MoeglichRec= RECORD
  220.                      x, y: ShortInt;
  221.                    END;
  222.     VAR
  223.       Fertig: BOOLEAN;
  224.       Moeglich: ARRAY[1..8] OF MoeglichRec;
  225.       Moeglichx, Moeglichy: ShortInt;
  226.       n, AnzMoeglich, AnzFlaechen: BYTE;
  227.       SprungX, SprungY,
  228.       FeldX, FeldY, ZufallsZahl: BYTE;
  229.     BEGIN
  230.       ClearFeld;
  231.       Zufallszahl := Random(45) + 20;
  232.       FeldX := Random(8) + 1;                              { Startfeld setzen }
  233.       FeldY := Random(8) + 1;
  234.       Level.x := FeldX;
  235.       Level.y := FeldY;
  236.       Level.Feld[FeldX, FeldY] := TRUE;
  237.       ShowFlaeche(FeldX, FeldY, FALSE);
  238.       AnzFlaechen := 0;
  239.       REPEAT
  240.         Inc(AnzFlaechen);
  241.         AnzMoeglich := 0;
  242.         FOR n := 1 TO 8 DO
  243.         BEGIN
  244.           CASE n OF
  245.             1: BEGIN
  246.                  Moeglichx := FeldX + 1;           { Alle Sprungmöglichkeiten }
  247.                  Moeglichy := FeldY;
  248.                END;
  249.             2: BEGIN
  250.                  Moeglichx := FeldX;
  251.                  Moeglichy := FeldY - 1;
  252.                END;
  253.             3: BEGIN
  254.                  Moeglichx := FeldX - 1;
  255.                  Moeglichy := FeldY;
  256.                END;
  257.             4: BEGIN
  258.                  Moeglichx := FeldX;
  259.                  Moeglichy := FeldY + 1;
  260.                END;
  261.             5: BEGIN
  262.                  Moeglichx := FeldX + 2;
  263.                  Moeglichy := FeldY;
  264.                END;
  265.             6: BEGIN
  266.                  Moeglichx := FeldX;
  267.                  Moeglichy := FeldY - 2;
  268.                END;
  269.             7: BEGIN
  270.                  Moeglichx := FeldX - 2;
  271.                  Moeglichy := FeldY;
  272.                END;
  273.             8: BEGIN
  274.                  Moeglichx := FeldX;
  275.                  Moeglichy := FeldY + 2;
  276.                END;
  277.           END; { Case }
  278.           IF (Moeglichx>0) AND (Moeglichx<9) AND     { Prüfen: Welche Sprünge }
  279.              (Moeglichy>0) AND (Moeglichy<9) THEN    { sind wirklich möglich? }
  280.             IF NOT Level.Feld[Moeglichx, Moeglichy] THEN
  281.             BEGIN
  282.               Inc(AnzMoeglich);
  283.               Moeglich[AnzMoeglich].x := Moeglichx;
  284.               Moeglich[AnzMoeglich].y := Moeglichy;
  285.             END;
  286.         END;
  287.         IF (AnzMoeglich=0) OR                         { Kein Zug mehr möglich }
  288.            (AnzFlaechen>ZufallsZahl) THEN                   { Zufalls-Abbruch }
  289.           Exit;
  290.         n := Random(AnzMoeglich) + 1;      { Möglichen Zug zufällig auswählen }
  291.         FeldX := Moeglich[n].x;
  292.         FeldY := Moeglich[n].y;
  293.         Level.Feld[FeldX, FeldY] := TRUE;
  294.         ShowFlaeche(FeldX, FeldY, FALSE);
  295.       UNTIL FALSE;
  296.     END;
  297.  
  298.   VAR
  299.     ch: CHAR;
  300.     xpos, ypos, xalt, yalt: BYTE;
  301.   BEGIN
  302.     REPEAT
  303.       FILE2Level(LevelNr1);
  304.       ShowRaum;
  305.       IF (Level.x>0) AND (Level.y>0) THEN
  306.       BEGIN
  307.         xpos := Level.x;
  308.         ypos := Level.y;
  309.       END
  310.       ELSE
  311.       BEGIN
  312.         xpos:=1;
  313.         ypos:=1;
  314.       END;
  315.       REPEAT
  316.         ShowFlaeche(xpos, ypos, TRUE);
  317.         ch := ReadKey;
  318.         CASE ch OF
  319.           #00: CASE ReadKey OF
  320.                  #72: IF ypos>1 THEN                            { Cursor hoch }
  321.                         Dec(ypos)
  322.                       ELSE
  323.                         ypos := 8;
  324.                  #80: IF ypos<8 THEN                          { Cursor runter }
  325.                         Inc(ypos)
  326.                       ELSE
  327.                         ypos := 1;
  328.                  #75: IF xpos>1 THEN                           { Cursor links }
  329.                         Dec(xpos)
  330.                       ELSE
  331.                         xpos := 8;
  332.                  #77: IF xpos<8 THEN                          { Cursor rechts }
  333.                         Inc(xpos)
  334.                       ELSE
  335.                         xpos := 1;
  336.                  #82: BEGIN
  337.                         Level.Feld[xpos, ypos] := TRUE;               { Einfg }
  338.                         IF NOT Level.Feld[Level.x, Level.y] THEN
  339.                         BEGIN
  340.                           Level.x := xpos;
  341.                           Level.y := ypos;
  342.                         END;
  343.                       END;
  344.                  #83: IF (xpos<>Level.x) OR (ypos<>Level.y) THEN
  345.                         Level.Feld[xpos, ypos] := FALSE;               { Entf }
  346.                END;
  347.           'z',
  348.           'Z': Zufall;                                                    { Z }
  349.           'l',
  350.           'L': ClearFeld;
  351.           's',
  352.           'S': IF Level.Feld[xpos, ypos] THEN                             { S }
  353.                BEGIN
  354.                  xalt := Level.x;
  355.                  yalt := Level.y;
  356.                  Level.x := xpos;
  357.                  Level.y := ypos;
  358.                  ShowFlaeche(xalt, yalt, FALSE);
  359.                END;
  360.         END;
  361.       UNTIL ch IN [#13, #27, '+', '-'];
  362.       CASE ch OF
  363.         #13: Level2FILE(LevelNr1);
  364.         '+': IF LevelNr1<AnzMaxRaeume THEN                                { + }
  365.                Inc(LevelNr1)
  366.              ELSE
  367.                LevelNr1 := 1;
  368.         '-': IF LevelNr1>1 THEN                                           { - }
  369.                Dec(LevelNr1)
  370.              ELSE
  371.                LevelNr1 := AnzMaxRaeume;
  372.       END;
  373.     UNTIL ch=#27;
  374.   END;
  375.  
  376. BEGIN
  377.   IF MitEingabe THEN
  378.   BEGIN
  379.     AlleFelderAusgabe;
  380.     EingabeFeld(5);
  381.     FeldLinks(3);
  382.     FeldLinks(4);
  383.     Info1 := 'LEVEL EDITIEREN';
  384.     Info2 := 'Geben Sie die Nummer des Levels ein:';
  385.     ZwischenWort := '';
  386.     LevelNr2 := 0;
  387.     REPEAT
  388.       MainMenu(Auswahl, FileName, Info1, Info2, LevelNr1,
  389.                ZwischenWort, LevelNr2, NormInfo3, NormInfo4, FALSE);
  390.       IF FeldVerlassen=27 THEN
  391.         Exit;
  392.     UNTIL LevelNr1>0;
  393.   END;
  394.   Editieren;
  395. END;
  396.  
  397. PROCEDURE ChangeRaum;                                { Zwei Level vertauschen }
  398.   PROCEDURE ChangeRunden(Runde1, Runde2: BYTE);
  399.   VAR
  400.     Zwischen: DatenRec;
  401.   BEGIN
  402.     Zwischen := Daten.Level[Runde1];
  403.     Daten.Level[Runde1] := Daten.Level[Runde2];
  404.     Daten.Level[Runde2] := Zwischen;
  405.   END;
  406.  
  407. VAR
  408.   Info1, Info2: Str80;
  409. BEGIN
  410.   LevelNr2 := 0;
  411.   AlleFelderNormal;
  412.   AlleFelderAusgabe;
  413.   FeldLinks(3);
  414.   FeldLinks(4);
  415.   EingabeFeld(5);
  416.   EingabeFeld(7);
  417.   Info1 := 'LEVEL TAUSCHEN';
  418.   Info2 := 'Welche Levels tauschen?';
  419.   ZwischenWort := 'tauschen gegen';
  420.   MainMenu(Auswahl, FileName, Info1, Info2, LevelNr1,
  421.            ZwischenWort, LevelNr2, NormInfo3, NormInfo4, FALSE);
  422.   IF FeldVerlassen=27 THEN
  423.     Exit;
  424.   IF (LevelNr1=LevelNr2) OR (LevelNr1=0) OR (LevelNr2=0) THEN
  425.   BEGIN
  426.     AlleFelderAusgabe;
  427.     Write(^G);
  428.     Info3 := 'Fehler: Falsche Levelnummern!';
  429.     Info4 := 'Tauschvorgang abgebrochen...';
  430.     MainMenu(Auswahl, FileName, Info1, Info2, LevelNr1,
  431.              ZwischenWort, LevelNr2, Info3, Info4, FALSE);
  432.     Pause;
  433.     Exit;
  434.   END;
  435.   ChangeRunden(LevelNr1, LevelNr2);
  436.   AlleFelderAusgabe;
  437.   Info3 := 'Levels erfolgreich getauscht!';
  438.   MainMenu(Auswahl, FileName, Info1, Info2, LevelNr1,
  439.            ZwischenWort, LevelNr2, Info3, WeiterInfo4, FALSE);
  440.   Pause;
  441. END;
  442.  
  443. PROCEDURE InsertRaum;                                 { Leeren Level einfügen }
  444. VAR
  445.   a: BYTE;
  446. BEGIN
  447.   AlleFelderAusgabe;
  448.   EingabeFeld(5);
  449.   Info1 := 'LEVEL EINFÜGEN';
  450.   Info2 := 'Vor welchem Level einfügen:';
  451.  
  452.   REPEAT
  453.     MainMenu(Auswahl, FileName, Info1, Info2, LevelNr1,
  454.              Zwischenwort, LevelNr2, NormInfo3, NormInfo4, FALSE);
  455.     IF FeldVerlassen=27 THEN
  456.       Exit;
  457.   UNTIL LevelNr1>0;
  458.  
  459.   FOR a := AnzMaxRaeume - 1 DOWNTO LevelNr1 DO
  460.     Daten.Level[a + 1] := Daten.Level[a];
  461.   Daten.Level[LevelNr1] := LeerRaum;
  462.  
  463.   AlleFelderAusgabe;
  464.   Info3 := 'Leerlevel eingefügt!';
  465.   MainMenu(Auswahl, FileName, Info1, Info2, LevelNr1,
  466.            Zwischenwort, LevelNr2, Info3, WeiterInfo4, FALSE);
  467.   Pause;
  468. END;
  469.  
  470. PROCEDURE DeleteRaum;                                         { Level löschen }
  471. VAR
  472.   a: BYTE;
  473. BEGIN
  474.   AlleFelderAusgabe;
  475.   EingabeFeld(5);
  476.   Info1 := 'LEVEL LÖSCHEN';
  477.   Info2 := 'Welcher Level soll gelöscht werden:';
  478.   REPEAT
  479.     MainMenu(Auswahl, FileName, Info1, Info2, LevelNr1,
  480.              Zwischenwort, LevelNr2, NormInfo3, NormInfo4, FALSE);
  481.     IF FeldVerlassen=27 THEN
  482.       Exit;
  483.   UNTIL LevelNr1>0;
  484.   FOR a := LevelNr1 TO AnzMaxRaeume - 1 DO
  485.     Daten.Level[a] := Daten.Level[a + 1];
  486.   Daten.Level[AnzMaxRaeume] := LeerRaum;
  487.   AlleFelderAusgabe;
  488.   Info3 := 'Level gelöscht!';
  489.   MainMenu(Auswahl, FileName, Info1, Info2, LevelNr1,
  490.            ZwischenWort, LevelNr2, Info3, WeiterInfo4, FALSE);
  491.   Pause;
  492. END;
  493.  
  494. PROCEDURE LoadNew;                                         { Neue Level laden }
  495. VAR
  496.   FileNameAlt: Str80;
  497.   n, a: BYTE;
  498.   NameOK: BOOLEAN;
  499. BEGIN
  500.   FileNameAlt := FileName;
  501.   AlleFelderAusgabe;
  502.   EingabeFeld(2);
  503.   EingabeFeldGross(2);
  504.   EingabeFeldSet(2, ['A'..'Z', '.']);
  505.   Info1 := 'NEUE LEVEL LADEN';
  506.   Info2 := 'Geben Sie oben den Dateinamen an';
  507.   FileName := '';
  508.   MainMenu(Auswahl, FileName, Info1, Info2, LevelNr1,
  509.            Zwischenwort, LevelNr2, NormInfo3, NormInfo4, FALSE);
  510.   IF FeldVerlassen=27 THEN
  511.   BEGIN
  512.     FileName := FileNameAlt;
  513.     Exit;
  514.   END;
  515.   a := 0;
  516.   FOR n := 1 TO Length(FileName) DO
  517.   BEGIN
  518.     IF FileName[n]='.' THEN
  519.       Inc(a);
  520.   END;
  521.   IF Pos('.', FileName)=0 THEN
  522.     FileName := FileName + '.LEV';
  523.   n := Pos('.', FileName);
  524.   IF n + 3 < Length(FileName) THEN
  525.     FileName := Copy(FileName, 1, n + 3);
  526.   LoadRunden;
  527.   IF IOFehler THEN
  528.     Exit;
  529.   AlleFelderAusgabe;
  530.   Info3 := 'Datei geladen!';
  531.   MainMenu(Auswahl, FileName, Info1, Info2, LevelNr1,
  532.            ZwischenWort, LevelNr2, Info3, WeiterInfo4, FALSE);
  533.   Pause;
  534. END;
  535.  
  536. { Hauptprogramm }
  537. BEGIN
  538.   CheckBreak := FALSE;
  539.   DirectVideo := TRUE;
  540.   Randomize;
  541.   TextMode(CO80);
  542.  
  543.   Auswahl := 0;
  544.   LeerInfo := '';
  545.   NormInfo3 := 'Arbeitsgang bestätigen mit <ENTER>';
  546.   NormInfo4 := 'oder abbrechen mit <ESC>';
  547.   WeiterInfo4 := 'Weiter mit einer Taste...';
  548.   BeiEndeFeldZumNaechstenSpringen := TRUE;
  549.   InitMaske;
  550.   FeldLinks(2);
  551.   FeldLinks(3);
  552.   FeldLinks(5);
  553.   FeldLinks(7);
  554.   FeldLinks(8);
  555.   AlleFelderAusgabe;
  556.   Info1 := 'DATEN EINLESEN';
  557.   Info2 := 'Von ' + Filename;
  558.   Info3 := '';
  559.   Info4 := 'Bitte etwas Geduld...';
  560.   LevelNr1 := 0;
  561.   LevelNr2 := 0;
  562.   Zwischenwort := '';
  563.   MainMenu(Auswahl, FileName, Info1, Info2, LevelNr1,
  564.            ZwischenWort, LevelNr2, Info3, Info4, TRUE);
  565.   LoadRunden;
  566.   IF IOFehler THEN
  567.     FOR LevelNr1 := 1 TO AnzMaxRaeume DO
  568.       Daten.Level[LevelNr1] := LeerRaum;
  569.   FeldVerlassenSet([0, 27]);
  570.   ShowMenuNeu := FALSE;
  571.   REPEAT
  572.     AlleFelderAusgabe;
  573.     EingabeFeld(1);
  574.     EingabeFeldSet(1, ['1'..'7']);
  575.     Auswahl := 0;
  576.     LevelNr1 := 0;
  577.     LevelNr2 := 0;
  578.     ZwischenWort := '';
  579.     MainMenu(Auswahl, FileName, LeerInfo, LeerInfo, LevelNr1,
  580.              ZwischenWort, LevelNr2, LeerInfo, LeerInfo, ShowMenuNeu);
  581.     ShowMenuNeu := FALSE;
  582.     IF FeldVerlassen=27 THEN
  583.     BEGIN
  584.       Info1 := 'PROGRAMM BEENDEN';
  585.       Info2 := 'Wollen Sie wirklich aufhören?';
  586.       MainMenu(Auswahl, FileName, Info1, Info2, LevelNr1,
  587.                ZwischenWort, LevelNr2, NormInfo3, NormInfo4, FALSE);
  588.       IF FeldVerlassen=0 THEN
  589.       BEGIN
  590.         RestoreCrtMode;
  591.         ClrScr;
  592.         Halt;
  593.       END;
  594.     END;
  595.     CASE Auswahl OF
  596.       1: EditRaum(TRUE);
  597.       2: ChangeRaum;
  598.       3: BEGIN
  599.            InsertRaum;
  600.            IF FeldVerlassen<>27 THEN
  601.              EditRaum(False);
  602.          END;
  603.       4: DeleteRaum;
  604.       5: LoadNew;
  605.       6: SaveRunden;
  606.       7: BEGIN
  607.            SaveRunden;
  608.            IF NOT IOFehler THEN
  609.            BEGIN
  610.              RestoreCrtMode;
  611.              ClrScr;
  612.              Halt;
  613.            END;
  614.          END;
  615.     END;
  616.     IF Auswahl IN [1..3] THEN
  617.     BEGIN
  618.       ShowMenuNeu := TRUE;
  619.       FeldLinks(2);
  620.       FeldLinks(3);
  621.       FeldLinks(5);
  622.       FeldLinks(7);
  623.       FeldLinks(8);
  624.     END;
  625.   UNTIL FALSE;
  626. END.
  627.  
  628.  
  629.  
  630.  
  631.  
  632.