home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / qpdemo / beispiel / objekt.pas < prev    next >
Encoding:
Pascal/Delphi Source File  |  1989-07-21  |  16.4 KB  |  553 lines
  1. PROGRAM objekte;
  2. {
  3.   OBJEKT.PAS   Objekt-Demonstrationsprogramm.
  4.  
  5.   Dieses Programm zeigt grafisch die Benutzung der objekt-orientierten
  6.   Erweiterung von QuickPascal. Auf dem Bildschirm sehen Sie Bitabbil-
  7.   dungen, die den Jogger und ein oder mehrere Hunde repräsentieren.
  8.   Jedes Mal, wenn der Jogger mit einem Hund zusammentrifft, wird er
  9.   gebissen; nachdem der Jogger mehrmals gebissen wird, gibt er auf.
  10.   Sie können das Programm durch Betätigen der ESC-Taste beenden.
  11.  
  12.   OBJEKT.PAS deklariert zwei Objekttypen: Hase und Fuchs
  13.   (eine Unterklasse von Hase).
  14.   Der Jogger ist Hase und der Hund ist Fuchs.
  15.   Verbunden mit dem Objekt Hase sind verschiedene Routinen (Methoden),
  16.   die initialisieren, bewegen, zeichnen, und löschen; Geschwindigkeit
  17.   setzen und die Richtung ändern; und Zusammenstöße registrieren.
  18.   Diese Methoden treffen auf Jogger und Hunde zu. Zusätzlich haben
  19.   die Fuchs-Objekte die Möglichkeit, die Richtung zu wechseln, wenn
  20.   der Jogger an ihnen vorbeiläuft. Dies wird Jagd genannt.
  21.  
  22. }
  23.  
  24. {$M+}  { Aktiviert Methodenprüfung. }
  25.  
  26. USES
  27.     MSGraph, Crt;
  28.  
  29. CONST
  30.     escape       = Chr( 27 );
  31.     ende_zaehler = 10;
  32.     max_hund     = 10;
  33.     max_schritte = 300;
  34.  
  35.     { ============== Bitabbildungen für Farbe ======================= }
  36.     { Mann läuft rückwärts }
  37.     mann_r : ARRAY[1..376] OF Byte = (
  38.              21,0,31,0,0,0,0,1,224,0,1,224,0,1,224,0,0,0,0,3,
  39.              240,0,3,240,0,3,240,0,3,224,0,3,240,0,3,240,0,3,
  40.              240,0,7,224,0,6,240,0,6,240,0,7,240,0,7,224,0,7,
  41.              240,0,7,240,0,7,240,0,3,224,0,3,240,0,3,240,0,3,
  42.              240,0,3,224,0,3,224,0,3,224,0,3,224,0,1,224,0,1,
  43.              224,0,1,224,0,1,224,0,1,224,0,1,0,0,1,0,0,1,224,
  44.              0,1,224,0,0,224,0,0,224,0,1,224,0,7,240,0,4,112,
  45.              0,4,112,0,7,240,0,207,248,0,204,56,0,204,56,0,207,
  46.              248,0,223,252,0,216,28,0,216,28,0,223,252,0,255,
  47.              238,0,248,14,0,248,14,0,255,238,0,119,231,0,112,
  48.              7,0,112,7,0,119,231,0,39,238,0,32,14,0,32,14,0,
  49.              39,238,0,7,252,0,0,28,0,0,28,0,7,252,0,3,232,0,
  50.              0,8,0,0,8,0,3,232,0,0,0,0,0,0,0,3,224,0,3,224,0,
  51.              0,0,0,0,0,0,3,240,0,3,240,0,0,0,0,0,0,0,7,248,0,
  52.              7,248,0,0,0,0,0,0,0,15,252,0,15,252,0,30,30,0,30,
  53.              30,0,30,30,0,30,30,0,60,15,0,60,15,0,60,15,0,60,
  54.              15,0,56,7,128,56,7,128,56,7,128,56,7,128,28,3,128,
  55.              28,3,192,28,3,192,28,3,128,14,1,0,14,1,224,14,1,
  56.              224,14,1,0,6,0,0,7,3,192,7,3,192,6,0,0,0,0,0,31,
  57.              7,128,31,7,128,0,0,0,0,0,0,63,0,0,63,0,0,0,0,0,
  58.              0,0,0,0,0,0,0,0,0,0,0,0);
  59.  
  60.     { Mann läuft vorwärts }
  61.     mann_v : ARRAY[1..376] OF Byte = (
  62.              21,0,31,0,0,0,0,0,120,0,0,120,0,0,120,0,0,0,0,0,
  63.              252,0,0,252,0,0,252,0,0,124,0,0,252,0,0,252,0,0,
  64.              252,0,0,126,0,0,246,0,0,246,0,0,254,0,0,126,0,0,
  65.              254,0,0,254,0,0,254,0,0,124,0,0,252,0,0,252,0,0,
  66.              252,0,0,124,0,0,124,0,0,124,0,0,124,0,0,120,0,0,
  67.              120,0,0,120,0,0,120,0,0,120,0,0,120,0,0,120,0,0,
  68.              120,0,0,120,0,0,0,0,0,0,0,0,120,0,0,248,0,0,152,
  69.              0,0,152,0,0,248,0,1,252,16,1,156,16,1,156,16,1,
  70.              252,16,3,254,48,3,142,48,3,142,48,3,254,48,7,127,
  71.              112,7,7,112,7,7,112,7,127,112,14,127,224,14,3,224,
  72.              14,3,224,14,127,224,7,127,192,7,1,192,7,1,192,7,
  73.              127,192,3,254,128,3,128,128,3,128,128,3,254,128,
  74.              1,124,0,1,0,0,1,0,0,1,124,0,0,0,0,0,0,0,0,124,0,
  75.              0,124,0,0,0,0,0,0,0,0,252,0,0,252,0,0,0,0,0,0,0,
  76.              1,254,0,1,254,0,0,0,0,0,0,0,3,255,0,3,255,0,7,135,
  77.              128,7,135,128,7,135,128,7,135,128,15,3,192,15,3,
  78.              192,15,3,192,15,3,192,30,1,192,30,1,192,30,1,192,
  79.              30,1,192,28,3,128,60,3,128,60,3,128,28,3,128,8,
  80.              7,0,120,7,0,120,7,0,8,7,0,0,6,0,60,14,0,60,14,0,
  81.              0,6,0,0,0,0,30,15,128,30,15,128,0,0,0,0,0,0,0,15,
  82.              192,0,15,192,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);
  83.  
  84.     { Hund läuft rückwärts }
  85.     hund_r : ARRAY[1..256] OF Byte = (
  86.              21,0,21,0,0,0,0,0,1,0,0,1,0,0,0,0,0,0,0,0,1,128,
  87.              0,1,128,0,0,0,0,0,0,0,0,192,0,0,192,0,0,0,0,0,0,
  88.              0,0,192,0,0,192,0,0,0,0,0,0,24,0,192,24,0,192,0,
  89.              0,0,0,0,0,24,0,192,24,0,192,0,0,0,0,0,0,28,0,192,
  90.              28,0,192,0,0,0,0,0,0,46,1,192,62,1,192,16,0,0,0,
  91.              0,0,255,255,192,255,255,192,0,0,0,0,0,0,255,255,
  92.              128,255,255,128,0,0,0,160,0,0,191,255,128,191,255,
  93.              128,0,0,0,64,0,0,95,255,128,95,255,128,0,0,0,0,
  94.              0,0,255,255,192,255,255,192,0,0,0,0,0,0,15,129,
  95.              224,15,129,224,0,0,0,0,0,0,13,193,240,13,193,240,
  96.              0,0,0,0,0,0,12,225,176,12,225,176,0,0,0,0,0,0,12,
  97.              113,160,12,113,160,0,0,0,0,0,0,12,225,160,12,225,
  98.              160,0,0,0,0,0,0,28,3,128,28,3,128,0,0,0,0,0,0,28,
  99.              3,128,28,3,128,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0);
  100.  
  101.     { Hund läuft vorwärts }
  102.     hund_v : ARRAY[1..256] OF Byte = (
  103.              21,0,21,0,0,0,0,8,0,0,8,0,0,0,0,0,0,0,0,24,0,0,
  104.              24,0,0,0,0,0,0,0,0,48,0,0,48,0,0,0,0,0,0,0,0,48,
  105.              0,0,48,0,0,0,0,0,0,0,0,48,1,128,48,1,128,0,0,0,
  106.              0,0,0,48,1,128,48,1,128,0,0,0,0,0,0,48,3,128,48,
  107.              3,128,0,0,0,0,0,0,56,7,64,56,7,192,0,0,128,0,0,
  108.              0,63,255,240,63,255,240,0,0,0,0,0,0,31,255,240,
  109.              31,255,240,0,0,0,0,0,80,31,255,208,31,255,208,0,
  110.              0,0,0,0,32,31,255,160,31,255,160,0,0,0,0,0,0,63,
  111.              255,240,63,255,240,0,0,0,0,0,0,120,31,0,120,31,
  112.              0,0,0,0,0,0,0,248,59,0,248,59,0,0,0,0,0,0,0,216,
  113.              115,0,216,115,0,0,0,0,0,0,0,88,227,0,88,227,0,0,
  114.              0,0,0,0,0,88,115,0,88,115,0,0,0,0,0,0,0,28,3,128,
  115.              28,3,128,0,0,0,0,0,0,28,3,128,28,3,128,0,0,0,0,
  116.              0,0,0,0,0,0,0,0,0,0,0);
  117.  
  118.     { ============== Bitabbildungen für Monochrom =================== }
  119.  
  120.     { Mann läuft rückwärts }
  121.     mann_r_m : ARRAY[1..37] OF Byte = (
  122.              21,0,11,0,0,112,0,0,248,0,0,112,0,195,255,0,102,
  123.              112,192,28,112,48,0,248,192,3,142,0,6,3,128,14,
  124.              3,0,0,0,0);
  125.  
  126.     { Mann läuft vorwärts }
  127.     mann_v_m : ARRAY[1..37] OF Byte = (
  128.              21,0,11,0,0,224,0,1,240,0,0,224,0,15,252,48,48,
  129.              230,96,192,227,128,49,240,0,7,28,0,28,6,0,12,7,
  130.              0,0,0,0);
  131.  
  132.     { Hund läuft rückwärts }
  133.     hund_r_m : ARRAY[1..37] OF Byte = (
  134.              21,0,11,0,4,0,32,252,0,48,236,0,48,252,0,48,31,
  135.              255,240,255,255,240,31,255,224,25,134,96,25,134,
  136.              96,59,142,224,0,0,0);
  137.  
  138.     { Hund läuft vorwärts }
  139.     hund_v_m : ARRAY[1..37] OF Byte = (
  140.              21,0,11,0,64,2,0,192,3,240,192,3,112,192,3,240,
  141.              255,255,128,255,255,240,127,255,128,102,25,128,
  142.              102,25,128,119,29,192,0,0,0);
  143.  
  144. TYPE
  145.  
  146.     Hase = object
  147.         { Beispieldaten }
  148.         bilder : ARRAY[1..2] OF POINTER;
  149.         igroesse : Word;          { Größe jeds Bitbildes }
  150.         x, y     : Word;          { Position: ulhc }
  151.         xe, ye   : Word;          { Ausdehnung }
  152.         vx, vy   : Integer;       { Schnelligkeit }
  153.         { Methoden }
  154.         PROCEDURE initialisieren( groesse, xe, ye : Word );
  155.         PROCEDURE bild_setzen( b1, b2 : POINTER );
  156.         PROCEDURE geschw_setzen( vx, vy : Integer );
  157.         PROCEDURE umdrehen;
  158.         PROCEDURE zeichnen;
  159.         PROCEDURE bewegen( x, y : Word );
  160.         PROCEDURE loeschen_obj;
  161.         PROCEDURE steigern( xl, yt, xr, yb : Word );
  162.         FUNCTION  kollidiert( s : Hase ) : Boolean;
  163.         PROCEDURE beenden;
  164.         END; { Hase }
  165.  
  166.      Fuchs = object( Hase )
  167.         PROCEDURE Jagd( x, y : Word );
  168.         END;
  169.  
  170. VAR
  171.     hunde       : ARRAY[1..max_hund] OF Fuchs;
  172.     mann        : Hase;
  173.     wl, wr,              { Maximum an Pixel - links, rechts }
  174.     wt, wb      : Word;  { Maximum an Pixel - oben, unten }
  175.     rFarbe      : Word;  { Randfarbe }
  176.     verzoegern  : Word;
  177.  
  178. { ======================= Hase.initialisieren ======================
  179.   Diese Prozedur initialisiert die Werte für die Hase-Objekte.
  180. }
  181.  
  182. PROCEDURE Hase.initialisieren( groesse, xe, ye : Word );
  183. BEGIN
  184.     self.igroesse := groesse;
  185.     self.xe := xe;
  186.     self.ye := ye;
  187.     self.vx := 0;
  188.     self.vy := 0;
  189. END;
  190.  
  191. { ======================= Hase.bild_setzen ========================
  192.   Diese Prozedur initialisiert die Bildpuffer für die Hase-Objekte
  193.   mit deren Bitabbildungen.
  194. }
  195. PROCEDURE Hase.bild_setzen( b1, b2 : POINTER );
  196. BEGIN
  197.     self.bilder[1] := b1;
  198.     self.bilder[2] := b2;
  199. END;
  200.  
  201. { ======================= Hase.geschw_setzen ======================
  202.   Diese Prozedur zeichnet die Geschwindigkeit der Hase-Objekte auf.
  203. }
  204. PROCEDURE Hase.geschw_setzen( vx, vy : Integer );
  205. BEGIN
  206.     self.vx := vx;
  207.     self.vy := vy;
  208. END;
  209.  
  210. { ======================= Hase.umdrehen ===========================
  211.   Diese Prozedur wird aufgerufen, wenn ein Hase-Objekt die Richtung
  212.   wechseln muß. Der Jogger wechselt die Richtung nur, wenn er den
  213.   Bildschirmrand erreicht. Die Hunde wechseln die Richtung, um den
  214.   Jogger zu verfolgen.
  215. }
  216. PROCEDURE Hase.umdrehen;
  217. BEGIN
  218.     self.loeschen_obj;
  219.     self.vx := -self.vx;
  220.     self.zeichnen;
  221. END;
  222.  
  223. { ======================= Hase.bewegen ==========================
  224.   Diese Prozedur bestimmt die Position des Hase-Objekts.
  225. }
  226.  
  227. PROCEDURE Hase.bewegen( x, y : Word );
  228. BEGIN
  229.     self.x := x;
  230.     self.y := y;
  231. END;
  232.  
  233. { ======================= Hase.zeichnen ===========================
  234.   Diese Prozedur zeichnet ein Hase-Objekt auf dem Bildschirm an der
  235.   aktuellen Position.
  236. }
  237.  
  238. PROCEDURE Hase.zeichnen;
  239. VAR
  240.     wi : Word;
  241. BEGIN
  242.     { Hase geht vorwärts, wenn der X-Vektor positiv ist,
  243.       sonst geht er rückwärts.
  244.     }
  245.     IF (self.vx > 0) THEN wi := 1 ELSE wi := 2;
  246.     _PutImage( self.x, self.y, self.bilder[wi]^, _Gxor );
  247. END;
  248.  
  249. { ======================= Hase.loeschen_obj ==========================
  250.   Diese Prozedur loescht das Hase-Objekt und wird aufgerufen, wenn die
  251.   Position auf den neusten Stand gebracht wird. Da zeichnen _Gxor,
  252.   loeschen_obj benutzt, wird einfach der gleiche Hase an der aktuellen
  253.   Position gezeichnet.
  254. }
  255.  
  256. PROCEDURE Hase.loeschen_obj;
  257. BEGIN
  258.     self.zeichnen;
  259. END;
  260.  
  261. { ======================= Hase.steigern ===========================
  262.   Diese Prozedur löschet den vorher gezeichneten Hasen, setzt eine
  263.   neue Position und zeichnet den nächsten Hasen.
  264. }
  265.  
  266. PROCEDURE Hase.steigern( xl, yt, xr, yb : Word );
  267. BEGIN
  268.     self.loeschen_obj;
  269.     Inc( self.x, self.vx );
  270.     Inc( self.y, self.vy );
  271.  
  272.     { Richtung wechseln, falls nicht mehr genug Platz für einen anderen
  273.       Hasen auf dem Bildschirm ist, der die gleiche Richtung benutzt.
  274.     }
  275.     IF ( self.x < xl) OR (self.x > (xr - self.xe)) THEN
  276.     BEGIN
  277.     self.vx := -self.vx;
  278.     Inc( self.x, self.vx );
  279.     END;
  280.     IF (self.y < yt) OR (self.y > (yb - self.ye)) THEN
  281.     BEGIN
  282.     self.vy := -self.vy;
  283.     Inc( self.y, self.vy );
  284.     END;
  285.     self.zeichnen;
  286. END;
  287.  
  288. { ======================= Hase.kollidiert ==========================
  289.   Diese Prozedur überprüft, ob zwei Hasen kollidierten.
  290. }
  291.  
  292. FUNCTION Hase.kollidiert( s : Hase ) : Boolean;
  293. VAR
  294.     x1, y1, x2, y2 : Word;
  295.     { ======================= erweitern ==========================
  296.       Diese Prozedur ergibt Wahr, falls Teile der Hasen überlappen.
  297.     }
  298.  
  299.     FUNCTION erweitern( x, y : Word ) : Boolean;
  300.     BEGIN
  301.     erweitern := (x >= self.x) AND (x < (self.x + self.xe)) AND
  302.                (y >= self.y) AND (y < (self.y + self.ye));
  303.     END;
  304.  
  305. BEGIN { Hase.kollidiert }
  306.     x1 := s.x;
  307.     y1 := s.y;
  308.     x2 := s.x + s.xe - 1;
  309.     y2 := s.y + s.ye - 1;
  310.     kollidiert := erweitern( x1, y1 ) OR erweitern( x1, y2 ) OR
  311.           erweitern( x2, y1 ) OR erweitern( x2, y2 );
  312. END;
  313.  
  314. { ======================= Hase.beenden ==========================
  315.   Diese Prozedur macht beim Programmende Speicher frei.
  316. }
  317.  
  318. PROCEDURE Hase.beenden;
  319. BEGIN
  320.     FreeMem( self.bilder[1], self.igroesse );
  321.     FreeMem( self.bilder[2], self.igroesse );
  322.     self.igroesse := 0;
  323. END;
  324.  
  325. { ======================= Fuchs.Jagd ==========================
  326.   Diese Prozedur wird für Fuchs-Objekte (Hunde) aufgerufen.
  327.   Es korrigiert die Richtung, wenn ein Jogger vorbeiläuft.
  328. }
  329.  
  330. PROCEDURE Fuchs.Jagd( x, y : Word );
  331. VAR
  332.     nvx, nvy : Integer;
  333. BEGIN
  334.     IF (x > self.x) THEN
  335.     nvx := Abs( self.vx )
  336.     ELSE
  337.     nvx := -Abs( self.vx );
  338.     IF (y > self.y) THEN
  339.     nvy := Abs( self.vy )
  340.     ELSE
  341.     nvy := -Abs( self.vy );
  342.     IF (nvx <> self.vx) THEN self.umdrehen;
  343.     self.vx := nvx;
  344.     self.vy := nvy;
  345. END;
  346.  
  347. { ======================= geschwindgk ==========================
  348.   Diese Funktion ergibt eine Geschwindigkeit in der bestimmten
  349.   Grenze.
  350. }
  351.  
  352. FUNCTION geschwindgk( min, max : Integer ) : Integer;
  353. VAR
  354.     grenze, num : Word;
  355. BEGIN
  356.     grenze := Abs( max - min );
  357.     geschwindgk := max - Random( grenze );
  358. END;
  359.  
  360. { ======================= initialisieren ==========================
  361.   Diese Prozedur initialisieret Variablen und Grafikmodus ujnd
  362.   zeichnet die ersten Objekte.
  363. }
  364.  
  365. PROCEDURE initialisieren;
  366. VAR
  367.     vidmodus  : Integer;
  368.     vidzeilen : Integer;
  369.     vc        : _VideoConfig;
  370.     n         : Word;
  371.  
  372. BEGIN
  373.  
  374.     { initialisiert Zufallszahlengenerator. }
  375.     Randomize;
  376.  
  377.     { Richtet Videoinformation ein }
  378.     DirectVideo := False;
  379.     vidmodus := _MaxResMode;
  380.     vidzeilen := _SetVideoMode( vidmodus );
  381.     _GetVideoConfig( vc );
  382.     IF (vc.Mode = _EResNoColor) THEN
  383.     BEGIN
  384.     vidzeilen := _SetVideoMode( _DefaultMode );
  385.     Writeln( 'Programm benötigt hochauflösenden Monochrom- oder '+
  386.          'CGA-Adapter' );
  387.     Halt( 1 );
  388.     END
  389.     ELSE IF (vc.Mode = _EResColor) AND (vc.Memory = 64) THEN
  390.     BEGIN    { Setzt richtigen Modus für 64K EGA. }
  391.     vidmodus := _HRes16Color;
  392.     vidzeilen := _SetVideoMode( _HRes16Color );
  393.     _GetVideoConfig( vc );
  394.     END;
  395.  
  396.     { Setzt maximale Anzahl der Pixel für links, rechts, oben, unten
  397.       und die Rundfarbe.
  398.     }
  399.     wl := 0;
  400.     wr := vc.NumXPixels - 1;
  401.     wt := vc.NumYPixels DIV vidzeilen + 1;
  402.     wb := vc.NumYPixels - 1;
  403.     rFarbe := vc.NumColors - 1;
  404.  
  405.     { Setzt Zeitverzögerung. }
  406.     IF (vc.NumColors = 16) THEN verzoegern := 0
  407.     ELSE verzoegern := 50;
  408.  
  409.     { Erstellt Bilder. }
  410.     New( mann );
  411.     IF (vc.NumColors = 16) THEN  { Farb-Bitabbildungen benutzen }
  412.     BEGIN
  413.     mann.initialisieren( SizeOf( mann_v ), 20, 30 );
  414.     mann.bild_setzen( @mann_v, @mann_r );
  415.     END
  416.     ELSE      { Monochrom-Bitabbildungen benutzen }
  417.     BEGIN
  418.     mann.initialisieren( SizeOf( mann_v_m ), 20, 10 );
  419.     mann.bild_setzen( @mann_v_m, @mann_r_m );
  420.     END;
  421.     mann.geschw_setzen( geschwindgk( -20, 20 ), geschwindgk( -10, 10 ) );
  422.     mann.bewegen( Random( wr - 21 ) + 1,
  423.                   Random( ( wb - wt -30 ) - 1 )    + wt );
  424.  
  425.     { erstellt Hunde. }
  426.     FOR n := 1 TO max_hund DO
  427.     BEGIN
  428.     New( hunde[n] );
  429.     IF (vc.NumColors = 16) THEN  { Farb-Bitabbildungen benutzen }
  430.         BEGIN
  431.         hunde[n].initialisieren( SizeOf( hund_v ), 30, 20 );
  432.         hunde[n].bild_setzen( @hund_v, @hund_r );
  433.         END
  434.     ELSE     { Monochrom-Bitabbildungen benutzen }
  435.         BEGIN
  436.         hunde[n].initialisieren( SizeOf( hund_v_m ), 20, 10 );
  437.         hunde[n].bild_setzen( @hund_v_m, @hund_r_m );
  438.         END;
  439.     hunde[n].geschw_setzen( 3, 1 );
  440.    END;
  441. END;  { Prozedur initialisieren }
  442.  
  443. { ======================= beenden ==========================
  444.   Diese Prozedur setzt den Videomodus zurück.
  445. }
  446.  
  447. PROCEDURE beenden;
  448. VAR
  449.     vidzeilen : Integer;
  450. BEGIN
  451.     vidzeilen := _SetVideoMode( _DefaultMode );
  452. END;
  453.  
  454. { ======================= spiel ==========================
  455.   Diese Prozedur macht die Hauptarbeit des Programms.
  456. }
  457.  
  458. PROCEDURE spiel;
  459. VAR
  460.     anzHunde    : Word;
  461.     n           : Word;
  462.     anzBiss     : Word;
  463.     anzSchritt  : Word;
  464.  
  465. BEGIN
  466.     FOR anzHunde := 1 TO max_hund DO
  467.     BEGIN
  468.     { Spielbereich erstellen. }
  469.     _ClearScreen( _GClearScreen );
  470.     _SetColor( rFarbe );
  471.     _Rectangle( _GBorder, wl, wt, wr, wb );
  472.  
  473.     { Anfangsposition zeichnen }
  474.     mann.zeichnen;
  475.     FOR n := 1 TO anzHunde DO
  476.         BEGIN
  477.         { Zufalls-Anfangsposition für Hunde auswählen. }
  478.         hunde[n].bewegen( Random( wr - 31 ) + 1,
  479.                   Random( (wb - wt - 20) - 1) + wt );
  480.         hunde[n].zeichnen;
  481.         END;
  482.  
  483.     anzBiss := 0;
  484.     FOR anzSchritt := max_schritte DOWNTO 0 DO
  485.         BEGIN
  486.         { Will Benutzer aufhören? }
  487.         IF KeyPressed THEN
  488.         IF (ReadKey = escape) THEN
  489.             BEGIN
  490.             GotoXY( 1, 1 );
  491.             Write( 'Jogger gibt auf!' );
  492.             Delay( 2000 );
  493.             Exit;
  494.             END; { beide IF-Anweisungen }
  495.  
  496.         { hunde.steigern - Jogger wird immer gebissen, wenn
  497.           er mit einem Hund kollidiert.
  498.         }
  499.         FOR n := 1 TO anzHunde DO
  500.         BEGIN
  501.         IF mann.kollidiert( hunde[n] ) THEN
  502.             BEGIN
  503.             Inc( anzBiss );
  504.             IF (anzBiss > ende_zaehler) THEN
  505.             BEGIN
  506.             GotoXY( 1, 1 );
  507.             Write( 'Jogger entscheidet, einen anderen Sport zu wählen.' );
  508.             Delay( 2000 );
  509.             Exit;
  510.             END;
  511.             GotoXY( 1, 1 );
  512.             Writeln( 'Autsch! Hund beißt Jogger.' );
  513.             Delay( 500 );
  514.             GotoXY( 1, 1 );
  515.             Writeln( '                                         ' );
  516.             END; { falls kollidiert }
  517.         hunde[n].steigern( wl, wt, wr, wb );
  518.         hunde[n].Jagd( mann.x, mann.y );
  519.         END; { for n := 1 to anzHunde }
  520.  
  521.         { Jogger steigern. }
  522.         mann.steigern( wl, wt, wr, wb );
  523.         Delay( verzoegern );
  524.         END; { for anzSchritt ... }
  525.  
  526.     { Jogger überlebt eine Runde. }
  527.     GotoXY( 1, 1 );
  528.     Write( 'Jogger überlebt ', anzHunde * 2,' Kilometer.' );
  529.     Delay( 2000 );
  530.     GotoXY( 1, 1 );
  531.     Writeln( '                                      ' );
  532.     END; { for anzHunde ... }
  533.  
  534.     { Jogger hat die "Schlacht" mit den Hunden überlebt. }
  535.     GotoXY( 1, 1 );
  536.     Writeln( 'Jogger erreicht Siegerland (weit nördlich des'+
  537.              ' Allgäus)!');
  538.     Delay( 2000 );
  539.     GotoXY( 1, 1 );
  540.     Writeln( '                     ' );
  541. END;
  542.  
  543. { =========================== Hauptprogramm =========================== }
  544.  
  545. BEGIN
  546.     initialisieren;
  547.     spiel;
  548.     beenden;
  549. END.
  550.  
  551.  
  552.  
  553.