home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1990 / 09 / ldm / wesp.pas < prev   
Encoding:
Pascal/Delphi Source File  |  1990-06-13  |  17.0 KB  |  576 lines
  1. (* ====================================================== *)
  2. (*                 WESP - Weltraumspringen                *)
  3. (*             (C) 1990 Thomas Perner & toolbox           *)
  4. (*               Compiler: Turbo Pascal ab 5.0            *)
  5. (* ====================================================== *)
  6.  
  7. PROGRAM Wesp;
  8. {$I-,R-,V-,S-,D-,L-}
  9.  
  10. USES
  11.   Crt, Dos, Graph;
  12.  
  13. TYPE
  14.   Str20 = STRING[20];
  15.   Str80 = STRING[80];
  16.   Datentyp = RECORD
  17.                Name: Str20;
  18.                Punkte: WORD;
  19.              END;
  20.  
  21. CONST
  22.   Punkte: WORD = 0;
  23.   Start_Ebene: BYTE = 1;
  24.   Zeitspeicher: WORD = 0;
  25.   Schwarz = 0;                            { Farben für CGA }
  26.   Gruen = 1;
  27.   Rot = 2;
  28.   Gelb = 3;
  29.   AnzSterne = 600;
  30.   AnzLevel = 30;
  31.  
  32. VAR
  33.   Treiber: INTEGER;
  34.   Figur: POINTER;
  35.   Figur_Spalte, Figur_Zeile: INTEGER;
  36.   Anzahl_Felder, Felder_Vernichtet: BYTE;
  37.   Liste: ARRAY[0..12] OF Datentyp;
  38.   Datei: FILE OF Datentyp;
  39.   Eintrag: Datentyp;
  40.   Punkte_Str: STRING[5];
  41.   Ebene_Str, Zeit_Str: STRING[3];
  42.   Sterne: ARRAY[1..AnzSterne] OF PointType;
  43.   I, J, X, Y, OffsetX: INTEGER;
  44.   Ende: BOOLEAN;
  45.   Dummy: STRING[6];
  46.   Hilfe: STRING[80];
  47.   Schrift, Hell, Hintergrund, Header, Taste, Ebene, Zeit,
  48.   Plattformrand, Plattformflaeche, A, TastByteAlt: BYTE;
  49.   Regs: REGISTERS;
  50.   TastByte: BYTE ABSOLUTE $0040:$0017;
  51.  
  52. PROCEDURE Figur_speichern;  { Figur als "Sprite" speichern }
  53. VAR
  54.   Z: WORD;
  55. BEGIN
  56.   ClearDevice;
  57.   SetColor(Schrift);
  58.   SetFillStyle(SolidFill, Hell);
  59.   Bar3D(0, 8 DIV A, 20 DIV A, 12 DIV A, 10 DIV A, TopOn);
  60.   FloodFill(10 DIV A, 4 DIV A, Schrift);
  61.   FloodFill(22 DIV A, 8 DIV A, Schrift);
  62.   FloodFill(26 DIV A, 6 DIV A, Schrift);
  63.   Z:=ImageSize(0, 0, 32 DIV A, 16 DIV A);
  64.   GetMem(Figur, Z);
  65.   GetImage(0, 0, 32 DIV A, 16 DIV A, Figur^);
  66. END;
  67.  
  68. PROCEDURE Schreibe(Spalte, Zeile: WORD;   { Textausgabe    }
  69.           Text: Str80; Farbe: BYTE);      { im Grafikmodus }
  70. BEGIN
  71.   Y:=TextHeight(Text)* 5 DIV 4;
  72.   X:=TextWidth(Text);
  73.   SetFillStyle(SolidFill, Hintergrund);      { Hintergrund }
  74.   Bar(Spalte, Zeile, Spalte+X, Zeile+Y);     { löschen     }
  75.   SetColor(Farbe);
  76.   OutTextXY(Spalte, Zeile, Text);
  77. END;
  78.  
  79. PROCEDURE Vorbereitungen;  { Grafik und Numlock aktivieren }
  80. VAR
  81.   Modus: INTEGER;
  82. BEGIN
  83.   Assign(Datei, 'WESP.DAT');          { Hi-Scores laden... }
  84.   Reset(Datei);
  85.   IF IOResult=0 THEN
  86.   BEGIN
  87.     FOR I:=1 TO 10 DO
  88.     BEGIN
  89.       Read(Datei, Eintrag);
  90.       Liste[I]:=Eintrag;
  91.     END;
  92.     Close(Datei);
  93.   END
  94.   ELSE
  95.     FOR I:=1 TO 10 DO              { ...oder neu erstellen }
  96.     BEGIN
  97.       Liste[I].Name:='Nobody';
  98.       Liste[I].Punkte:=110-I*10;
  99.     END;
  100.  
  101.   Treiber:=Detect;
  102.   DetectGraph(Treiber, Modus);
  103.   CASE Treiber OF     { Variablen auf Grafikkarte anpassen }
  104.     EGA,
  105.     VGA: BEGIN
  106.            Treiber:=EGA;
  107.            Modus:=EGAHi;
  108.            Schrift:=LightGray;
  109.            Hell:=White;
  110.            Hintergrund:=Black;
  111.            Header:=LightRed;
  112.            Plattformrand:=Green;
  113.            Plattformflaeche:=LightGreen;
  114.            A:=1;
  115.            OffsetX:=0;
  116.          END;
  117.     HercMono:
  118.          BEGIN
  119.            Treiber:=HercMono;
  120.            Modus:=HercMonoHi;
  121.            Schrift:=1;
  122.            Hell:=1;
  123.            Header:=1;
  124.            Hintergrund:=Black;
  125.            Plattformrand:=1;
  126.            Plattformflaeche:=1;
  127.            A:=1;
  128.            OffsetX:=50;
  129.          END;
  130.     MCGA,
  131.     CGA: BEGIN
  132.            Treiber:=CGA;
  133.            Modus:=CGAC0;
  134.            Schrift:=Rot;
  135.            Hell:=Gruen;
  136.            Header:=Gelb;
  137.            Hintergrund:=Schwarz;
  138.            Plattformrand:=Rot;
  139.            Plattformflaeche:=Gruen;
  140.            A:=2;
  141.            OffsetX:=8;
  142.          END;
  143.   ELSE                                           { Hoppla! }
  144.     writeln(^G, 'Was haben Sie denn für eine Grafikkarte?');
  145.     writeln(#10#13, 'Sorry - die kenne ich leider nicht!');
  146.     Halt;
  147.   END;
  148.   InitGraph(Treiber, Modus, '');
  149.   IF GraphResult<>0 THEN
  150.   BEGIN                                 { Nicht vergessen! }
  151.     writeln(^G,'Wo haben Sie denn Ihre BGI-Treiber?'#10#13);
  152.     writeln('Bitte schnell in mein Verzeichnis damit!');
  153.     Halt;
  154.   END;
  155.   SetTextJustify(LeftText, TopText);           { Sonstiges }
  156.   Figur_speichern;
  157.   CheckBreak:=FALSE;
  158.   TastByteAlt:=TastByte;             { NumLock einschalten }
  159.   TastByte:=TastByte OR 32;    { LED bleibt unbeeinflusst! }
  160. END;
  161.  
  162. PROCEDURE Plattform(Spalte, Zeile: BYTE; Zeichnen: BOOLEAN);
  163.                          { Plattform zeichnen oder löschen }
  164. BEGIN
  165.   X:=Spalte*(50 DIV A)-Zeile*(26 DIV A)+160 DIV A+OffsetX;
  166.   Y:=Zeile*(24 DIV A)+76 DIV A;
  167.   IF Zeichnen THEN
  168.   BEGIN                                      { Zeichnen... }
  169.     SetColor(Plattformrand);
  170.     SetFillStyle(SolidFill, Plattformflaeche);
  171.     Bar3D(X, Y, X+40 DIV A, Y-4 DIV A, 22 DIV A, TopOn);
  172.     FloodFill(X+6 DIV A, Y-6 DIV A, Plattformrand);
  173.     FloodFill(X+46 DIV A, Y-6 DIV A, Plattformrand);
  174.     IF Treiber=HercMono THEN
  175.     BEGIN
  176.       SetColor(Hintergrund);
  177.       Bar3D(X, Y, X+40 DIV A, Y-4 DIV A, 22 DIV A, TopOn);
  178.     END;
  179.   END
  180.   ELSE
  181.   BEGIN                                   { ...und löschen }
  182.     IF Treiber=HercMono THEN
  183.     BEGIN
  184.       SetColor(Hintergrund);
  185.       SetFillStyle(SolidFill, Hintergrund);
  186.       Bar3D(X, Y, X+40 DIV A, Y-4 DIV A, 22 DIV A, TopOn);
  187.       FloodFill(X+6 DIV A, Y-6 DIV A, Hintergrund);
  188.       FloodFill(X+46 DIV A, Y-6 DIV A, Hintergrund);
  189.     END
  190.     ELSE
  191.     BEGIN
  192.       SetColor(Plattformrand);
  193.       SetFillStyle(SolidFill, Hintergrund);
  194.       FloodFill(X+6 DIV A, Y-6 DIV A, Plattformrand);
  195.       FloodFill(X+46 DIV A, Y-6 DIV A, Plattformrand);
  196.       SetColor(Hintergrund);
  197.       Bar3D(X, Y, X+40 DIV A, Y-4 DIV A, 22 DIV A, TopOn);
  198.     END;
  199.   END;
  200. END;
  201.  
  202. PROCEDURE Piep;                                   { Pieps! }
  203. VAR
  204.   S: WORD;
  205. BEGIN
  206.   S:=100;
  207.   WHILE S<2000 DO
  208.   BEGIN
  209.     Sound(S);
  210.     INC(S);
  211.   END;
  212.   NoSound;
  213. END;
  214.  
  215. PROCEDURE Spielfigur(Spalte, Zeile: BYTE);
  216.                           { Zeichnet und löscht Spielfigur }
  217. VAR
  218.   S: WORD;
  219. BEGIN
  220.   X:=Spalte*(50 DIV A)-Zeile*(26 DIV A)+176 DIV A+OffsetX;
  221.   Y:=Zeile*(24 DIV A)+58 DIV A;
  222.   PutImage(X, Y, Figur^, XORPUT);
  223.   IF I=1 THEN               { Sound für einen einfachen... }
  224.   BEGIN
  225.     Sound(150);
  226.     Delay(1);
  227.     NoSound;
  228.     Delay(1);
  229.     Sound(100);
  230.     Delay(1);
  231.     NoSound;
  232.   END
  233.   ELSE
  234.     Piep;             { ... und für einen doppelten Sprung }
  235. END;
  236.  
  237. PROCEDURE DrawSterne;             { Sternenhimmel zeichnen }
  238. BEGIN
  239.   FOR I:=1 TO AnzSterne DO
  240.   BEGIN
  241.     REPEAT
  242.       x:=Random(GetMaxX);
  243.       y:=Random(GetMaxY);
  244.     UNTIL GetPixel(x, y)=Hintergrund;
  245.     Sterne[I].x:=x;
  246.     Sterne[I].y:=y;
  247.     PutPixel(Sterne[I].x, Sterne[I].y,
  248.              Succ(Random(GetMaxColor)));
  249.   END;
  250. END;
  251.  
  252. PROCEDURE Sternenflimmern;   { Sterne bunt flimmern lassen }
  253. VAR
  254.   n: WORD;
  255. BEGIN
  256.   n:=Succ(Random(AnzSterne));
  257.   PutPixel(Sterne[n].x, Sterne[n].y,
  258.            Random(Succ(GetMaxColor)));
  259. END;
  260.  
  261. PROCEDURE Spielfeld_aufbauen(Feld_Nr: BYTE);
  262.                              { Daten für Level aufbereiten }
  263. CONST
  264.   Feld: ARRAY[1..AnzLevel, 1..10] OF BYTE=
  265.         (($08,$7E,$48,$48,$CE,$82,$FE,$00,$07,$02),
  266.          ($40,$78,$47,$40,$5C,$08,$78,$00,$07,$03),
  267.          ($00,$04,$2E,$04,$20,$74,$20,$00,$06,$04),
  268.          ($40,$55,$45,$05,$01,$70,$07,$1F,$02,$03),
  269.          ($20,$20,$70,$28,$4A,$DE,$42,$00,$05,$05),
  270.          ($28,$20,$0C,$78,$04,$A0,$2C,$00,$05,$04),
  271.          ($20,$75,$0B,$09,$3E,$2B,$02,$00,$03,$01),
  272.          ($00,$07,$29,$3C,$01,$1E,$01,$03,$05,$04),
  273.          ($1E,$60,$1C,$AA,$E8,$82,$A0,$AF,$07,$01),
  274.          ($75,$0C,$4B,$25,$EA,$A4,$FA,$14,$07,$03),
  275.          ($02,$42,$4E,$CC,$48,$34,$E0,$A0,$07,$02),
  276.          ($14,$5F,$54,$E5,$4F,$20,$1C,$28,$06,$04),
  277.          ($2D,$25,$3A,$20,$17,$2A,$00,$00,$07,$03),
  278.          ($08,$E9,$3F,$40,$E9,$5B,$08,$6A,$07,$03),
  279.          ($A9,$20,$AB,$76,$02,$98,$CA,$B8,$02,$07),
  280.          ($BE,$A8,$5D,$AA,$49,$BA,$C9,$95,$05,$07),
  281.          ($E8,$1C,$48,$5C,$C8,$48,$40,$00,$05,$03),
  282.          ($FF,$89,$A9,$8F,$81,$A5,$81,$FF,$05,$08),
  283.          ($00,$79,$A1,$C5,$A4,$75,$04,$2E,$04,$06),
  284.          ($28,$26,$08,$F2,$08,$12,$1E,$0A,$05,$05),
  285.          ($07,$16,$F8,$5A,$06,$02,$5E,$E8,$05,$04),
  286.          ($04,$05,$04,$1F,$14,$51,$E8,$4D,$02,$07),
  287.          ($F5,$07,$32,$0E,$D4,$2C,$80,$F8,$01,$08),
  288.          ($00,$55,$BB,$51,$A2,$0A,$7A,$42,$03,$07),
  289.          ($F7,$14,$14,$F7,$81,$81,$F7,$00,$08,$01),
  290.          ($A8,$DD,$09,$1C,$09,$11,$75,$39,$06,$04),
  291.          ($07,$04,$12,$16,$3B,$42,$E3,$78,$05,$08),
  292.          ($AB,$55,$A8,$57,$6A,$F2,$40,$00,$04,$06),
  293.          ($5A,$C0,$B5,$2A,$95,$B7,$94,$2C,$06,$06),
  294.          ($FF,$FF,$FF,$FF,$FF,$FF,$FF,$FF,$08,$01));
  295.   Wert: ARRAY[1..8] OF BYTE=(128, 64, 32, 16, 8, 4, 2, 1);
  296. VAR
  297.   x, y: INTEGER;
  298. BEGIN
  299.   ClearDevice;                      { Statuszeile aufbauen }
  300.   SetColor(Schrift);
  301.   OutTextXY(0, 0, 'Punkte');
  302.   OutTextXY(250 DIV A, 0, 'Bonus');
  303.   OutTextXY(500 DIV A, 0, 'Ebene');
  304.   Figur_Spalte:=Feld[Feld_Nr, 9];          { Startposition }
  305.   Figur_Zeile:=Feld[Feld_Nr, 10];
  306.   IF Feld_Nr>AnzLevel THEN         { Alle Level geschafft: }
  307.     Exit;                                      { Spielende }
  308.   Anzahl_Felder:=0;                 { Plattformen zeichnen }
  309.   FOR I:=1 TO 8 DO
  310.     FOR J:=1 TO 8 DO
  311.     BEGIN
  312.       IF Feld[Feld_Nr, I] AND Wert[J] <> 0 THEN
  313.       BEGIN
  314.         INC(Anzahl_Felder);
  315.         Plattform(J, I, TRUE);
  316.       END;
  317.     END;
  318.     DrawSterne;
  319. END;
  320.  
  321. PROCEDURE Zeitroutine;                { Bonuszeit anzeigen }
  322. VAR
  323.   Stunde, Minute, Sekunde, Hunderstel: WORD;
  324. BEGIN
  325.   GetTime(Stunde, Minute, Sekunde, Hunderstel);
  326.   IF (Sekunde<>Zeitspeicher) AND (Zeit>0) THEN
  327.   BEGIN
  328.     Zeitspeicher:=Sekunde;
  329.     DEC(Zeit);
  330.     Str(Zeit, Zeit_Str);
  331.     Schreibe(380 DIV A, 0, Zeit_Str+#32, Schrift);
  332.   END;
  333. END;
  334.  
  335. PROCEDURE Tastaturpuffer_loeschen;
  336. BEGIN
  337.   Regs.AX:=$0C00;
  338.   MsDos(Regs);
  339. END;
  340.  
  341. PROCEDURE SpielEnde;                      { Grafik beenden }
  342. BEGIN
  343.   CloseGraph;
  344.   TastByte:=TastByteAlt; { NumLock-Status wiederherstellen }
  345.   Halt;
  346. END;
  347.  
  348. PROCEDURE Tastendruck(Blink: BOOLEAN);       { Taste holen }
  349. BEGIN
  350.   Tastaturpuffer_loeschen;
  351.   REPEAT
  352.     IF Blink THEN            { evtl. Sterne blinken lassen }
  353.       Sternenflimmern;
  354.   UNTIL KeyPressed;
  355. END;
  356.  
  357. FUNCTION Eingabe(Zeile, Spalte: WORD; Max: BYTE;
  358.          Zahlen, Blink: BOOLEAN): Str20;   { Alle Eingaben }
  359. BEGIN
  360.   Hilfe:='';
  361.   SetFillStyle(SolidFill, Hintergrund);
  362.   REPEAT
  363.     Schreibe(Spalte, Zeile, Hilfe+#60#32#32#32, Hell);
  364.     Tastendruck(Blink);
  365.     Taste:=Ord(ReadKey);
  366.     IF Taste=0 THEN
  367.     BEGIN
  368.       Taste:=Ord(ReadKey);
  369.       Taste:=0;
  370.     END;
  371.     IF Taste=8 THEN { Backspace }
  372.       Delete(Hilfe, Length(Hilfe), 1);
  373.     IF Zahlen THEN                         { Zahleneingabe }
  374.     BEGIN
  375.       IF Taste=27 THEN                       { ESC -> Ende }
  376.         SpielEnde;
  377.       IF (Taste in [48..57]) AND (Max>Length(Hilfe)) THEN
  378.         Hilfe:=Concat(Hilfe, Chr(Taste));
  379.     END
  380.     ELSE                                     { Texteingabe }
  381.       IF (Taste in [32, 48..57, 65..90, 97..122]) AND
  382.          (Max>Length(Hilfe)) THEN
  383.         Hilfe:=Concat(Hilfe, Chr(Taste));
  384.   UNTIL Taste=13;
  385.   Eingabe:=Hilfe
  386. END;
  387.  
  388. PROCEDURE Spiel;                     { Hauptprozedur Spiel }
  389. BEGIN
  390.   Ebene:=Start_Ebene-1;         { Punkte etc. zurücksetzen }
  391.   Punkte:=0;
  392.   Str(Punkte, Punkte_Str);
  393.   Ende:=FALSE;
  394.   REPEAT
  395.     Tastaturpuffer_loeschen;    { Variablen initialisieren }
  396.     INC(Ebene);
  397.     Str(Ebene, Ebene_Str);
  398.     Spielfeld_aufbauen(Ebene);
  399.     Felder_Vernichtet:=0;
  400.     Zeit:=101;
  401.     Str(Zeit, Zeit_Str);
  402.     Schreibe(140 DIV A, 0, Punkte_Str, Schrift); { Status- }
  403.     Schreibe(380 DIV A, 0, Zeit_Str, Schrift);   { zeile   }
  404.     Schreibe(600 DIV A, 0, Ebene_Str, Schrift);
  405.     I:=1;
  406.     Spielfigur(Figur_Spalte, Figur_Zeile);
  407.     REPEAT                               { Schleifenanfang }
  408.       Zeitroutine;
  409.       Sternenflimmern;
  410.       IF KeyPressed THEN
  411.       BEGIN                               { Taste gedrückt }
  412.         I:=1;
  413.         Spielfigur(Figur_Spalte, Figur_Zeile);
  414.         Taste:=Ord(ReadKey);
  415.         IF Taste=27 THEN     { ESC -> zurück zum Hauptmenü }
  416.         BEGIN
  417.           Punkte:=0;
  418.           Exit;
  419.         END;
  420.         IF Taste=0 THEN
  421.           Taste:=Ord(ReadKey);
  422.         IF Taste In [72, 80, 77, 75, 56, 50, 54, 52] THEN
  423.         BEGIN                       { Spielzug durchführen }
  424.           Plattform(Figur_Spalte, Figur_Zeile, FALSE);
  425.           INC(Felder_Vernichtet);
  426.           INC(Punkte, 10);
  427.           Str(Punkte, Punkte_Str);
  428.           Schreibe(140 DIV A, 0, Punkte_Str, Schrift);
  429.           I:=1;
  430.           IF Taste in [72, 80, 77, 75] then
  431.             I:=2;
  432.           CASE Taste OF
  433.             72, 56: DEC(Figur_Zeile, I);   { Cursor hoch   }
  434.             80, 50: INC(Figur_Zeile, I);   { Cursor runter }
  435.             77, 54: INC(Figur_Spalte, I);  { Cursor rechts }
  436.             75, 52: DEC(Figur_Spalte, I);  { Cursor links  }
  437.           END;
  438.           X:=Figur_Spalte*(50 DIV A)-
  439.              Figur_Zeile*(26 DIV A)
  440.              +170 DIV A+OffsetX;
  441.           Y:=Figur_Zeile*(24 DIV A)+66 DIV A;
  442.           IF (GetPixel(X, Y)=Hintergrund) AND
  443.              (Felder_Vernichtet<Anzahl_Felder)  THEN
  444.             Ende:=TRUE     { Pech gehabt: Sprung ins Leere }
  445.         END;
  446.         IF (Felder_Vernichtet<Anzahl_Felder) AND (Not(Ende))
  447.         THEN
  448.           Spielfigur(Figur_Spalte, Figur_Zeile);  { Zug OK }
  449.       END;
  450.     UNTIL (Ende) OR (Felder_Vernichtet=Anzahl_Felder) OR
  451.           (Ebene>AnzLevel);                   { Rundenende }
  452.     IF (Ebene>AnzLevel) THEN       { Alle Runden geschafft }
  453.       Exit;
  454.     IF Felder_Vernichtet=Anzahl_Felder THEN
  455.     BEGIN                                { Runde geschafft }
  456.       INC(Punkte, Zeit);
  457.       Zeit:=0;
  458.       Str(Zeit, Zeit_Str);
  459.       Str(Punkte, Punkte_Str);
  460.       FOR I:=1 TO 3 DO
  461.       BEGIN
  462.         Piep;
  463.         Delay(100);
  464.       END;
  465.       Schreibe(140 DIV A, 0, Punkte_Str, Schrift);
  466.       Schreibe(380 DIV A, 0, Zeit_Str+#32, Schrift);
  467.       Tastendruck(TRUE);
  468.     END;
  469.   UNTIL Ende;
  470.   I:=1000;                                { Spiel verloren }
  471.   WHILE I>100 DO
  472.   BEGIN
  473.     Sound(Random(I)+100);
  474.     Delay(1);
  475.     DEC(I);
  476.   END;
  477.   NoSound;
  478.   Schreibe(GetMaxX DIV 2-TextWidth('XXXX'), GetMaxY DIV 2,
  479.            'GAME OVER', Hell);
  480.   Tastendruck(TRUE);
  481. END;
  482.  
  483. PROCEDURE Hauptmenue;                          { Titelbild }
  484. BEGIN
  485.   ClearDevice;
  486.   SetColor(Hell);
  487.   Rectangle(0, 0, GetMaxX, GetMaxY);
  488.   SetTextStyle(GothicFont, HorizDir, 1);
  489.   SetTextJustify(LeftText, TopText);
  490.   IF Treiber=CGA THEN         { Größe Überschrift anpassen }
  491.     SetUserCharSize(4, 3, 6, 7)
  492.   ELSE
  493.     SetUserCharSize(5, 2, 5, 3);
  494.   SetColor(Header);
  495.   OutTextXY(GetMaxX DIV 20, 0, 'WESP');
  496.  
  497.   I:=0;                                 { Neuer Hi-Score ? }
  498.   Ende:=FALSE;
  499.   REPEAT
  500.     INC(I);
  501.     IF Punkte>Liste[I].Punkte THEN
  502.     BEGIN
  503.       IF I<10 THEN
  504.         FOR J:=10 DownTo I DO
  505.           Liste[J]:=Liste[J-1];
  506.       Liste[I].Name:='';
  507.       Liste[I].Punkte:=Punkte;
  508.       Ende:=TRUE;
  509.     END;
  510.   UNTIL (Ende) OR (I=12);
  511.   CASE Treiber OF       { Schrift je nach Auflösung setzen }
  512.     HercMono,
  513.     EGA: BEGIN
  514.            SetTextStyle(TriplexFont, HorizDir, 1);
  515.            SetUserCharSize(3, 4, 2, 3);
  516.          END;
  517.     CGA: BEGIN
  518.            SetTextStyle(DefaultFont, HorizDir, 1);
  519.            SetUserCharSize(1, 3, 1, 3);
  520.          END;
  521.   END;
  522.   OutTextXY(4*GetMaxX DIV 9, GetMaxY DIV 30,
  523.             '(c) ''90 Th. Perner');
  524.   OutTextXY(4*GetMaxX DIV 9, 3*GetMaxY DIV 30,
  525.             ' &  t o o l b o x');
  526.   FOR J:=1 TO 10 DO              { Hi-Score-Liste anzeigen }
  527.   BEGIN
  528.     y:=GetMaxY DIV 16*(J+2);
  529.     IF J=I THEN
  530.       SetColor(Hell)
  531.     ELSE
  532.       SetColor(Schrift);
  533.     Str(J:2,Dummy);
  534.     OutTextXY(GetMaxX DIV 20, y, Dummy);
  535.     OutTextXY(GetMaxX DIV 7, y, Liste[J].Name);
  536.     Str(Liste[J].Punkte:5, Dummy);
  537.     OutTextXY(5*GetMaxX DIV 6, y, Dummy);
  538.   END;
  539.  
  540.   IF Ende AND (I<11) THEN
  541.   BEGIN
  542.     SetColor(Hell);
  543.     y:=GetMaxY DIV 16*(I+2);
  544.     Liste[I].Name:=Eingabe(y, GetMaxX DIV 7, 20, FALSE,
  545.                            FALSE);
  546.     Assign(Datei, 'WESP.DAT');
  547.     ReWrite(Datei);               { Neue Liste abspeichern }
  548.     FOR J:=1 TO 10 DO
  549.       Write(Datei, Liste[J]);
  550.     Close(Datei);
  551.   END;
  552.  
  553.   Schreibe(GetMaxX DIV 20, GetMaxY DIV 16*14,
  554.            'Gib die Startebene ein: '+
  555.            +'(1-16)', Schrift);
  556.   Schreibe(GetMaxX DIV 20, GetMaxY DIV 16*15,
  557.            '0 -> Programmende', Schrift);
  558.   DrawSterne;
  559.   REPEAT                             { Eingabe Levelnummer }
  560.     Dummy:=Eingabe(GetMaxY DIV 16*14, 5*GetMaxX DIV 6, 2,
  561.                    TRUE, TRUE);
  562.     Val(Dummy, Start_Ebene, X);
  563.   UNTIL (Start_Ebene>=0) AND (Start_Ebene<17);
  564.   IF Start_Ebene=0 THEN
  565.     SpielEnde;                     { 0 -> Programm beenden }
  566. END;
  567.  
  568. BEGIN                                      { HAUPTPROGRAMM }
  569.   Vorbereitungen;
  570.   REPEAT
  571.     Hauptmenue;
  572.     Spiel;
  573.   UNTIL FALSE;
  574. END.
  575. (* ====================================================== *)
  576.