zweidimensionale Arrays

[Mo53]

Hallo,

Ich muss jetzt für die Uni das Spiel Minesweeper nachbauen.

Hier einmal die Anforderungen:

Das bekannte Spiel Minesweeper soll von Euch nachgebaut werden.
Zunächst wird dabei jeweils das Spielfeld mit allen noch verdeckten Zellen sowie den bereits aufgedeckten Zahlen und Bomben in der Konsole ausgegeben. Der Spieler gibt dann die Spalte und danach die Zeile (jeweils ab 1) an (in zwei getrennten Eingaben), in die er "klicken" will sowie zusätzlich eine Angabe, ob dort die Zelle aufgedeckt oder eine Bombe markiert werden soll. Sind die Angaben ungültig (und nicht z.B. eine zu große/kleine Zahl oder ein zu langer String), erscheint eine passende Fehlermeldung und die Eingabe aller drei Werte muß wiederholt werden. Nach einer erfolgreichen Eingabe wird das aktualisierte Spielfeld erneut ausgegeben. Das Spiel endet, wenn alle Zellen außer denen mit Bomben aufgedeckt wurden, wenn der Spieler eine Bombe "aufgedeckt" hat, wenn er eine Zelle fälschlicherweise als Bombe markiert hat oder wenn bei einer der Eingaben mit x/X das Spiel abgebrochen wurde.

Anforderungen
Zunächst sind verschiedene Konstanten und Typen anzulegen:
eine Konstante FIELDSIZE für die Spielfeldbreite bzw. -höhe (das Feld ist also immer quadratisch). Initial könnt Ihr diese auf 7 setzen, andere Größen sollen aber auch möglich sein!
einen Teilbereichstyp TSize für die somit definierte Breite bzw. Höhe (von 1 bis zu der Konstanten)
ein Aufzählungstyp TState für die Zustände einer Zelle des Spielfeldes mit den Werten "leer" und "Bombe"
ein 2D-Array TField in Breite und Höhe entsprechend dem Teilbereichstyp mit dem Aufzählungstyp als Basistyp
ein 2D-Array TVisible in Breite und Höhe entsprechend dem Teilbereichstyp mit Boolean als Basistyp
ein weiterer Aufzählungstyp TDir für die 8 Himmelsrichtungen Nord, NordOst, Ost, SüdOst, Süd, SüdWest, West und NordWest (siehe Hilfe)
je eine Konstante OFFSET_X und OFFSET_Y exakt wie hier vorgegeben (siehe Hilfe):
OFFSET_X: array [TDir] of integer = (0, 1, 1, 1, 0, -1, -1, -1);
OFFSET_Y: array [TDir] of integer = (1, 1, 0, -1, -1, -1, 0, 1);
Danach benötigt Ihr natürlich auch Variablen von den angelegten Typen, konkret mindestens eine von jedem Array und zwei vom Teilbereichstypen, um damit durch das Array zu laufen (denkt dran: ein Typ ist nur eine abstrakte Beschreibung einer Datenstruktur, ihm kann nichts zugewiesen werden!) sowie ein paar weitere ob abgebrochen wurde etc.
Die Variablen dürfen dabei nur direkt vor dem Hauptprogramm deklariert werden, globale Variablen (also solche, die über den Funktionen/Prozeduren deklariert werden), sind nicht erlaubt! Typen und Konstanten hingegen dürfen und sollen gerne zu Beginn des Programms angelegt werden, denn ansonsten sind sie ja in den Funktionen/Prozeduren auch nicht benutzbar.

Prüft an dieser Stelle (indem Ihr einen Abnehmer fragt, wenn Ihr selbst nicht sicher seid), daß die Konstanten und Typen wie gefordert angelegt wurden. Ihr erzeugt Euch ansonsten viel unnötigen Aufwand, wenn diese später noch geändert werden müssen!

Das Hauptprogramm steuert den gesamten Ablauf, insb. soll sich dort eine Schleife befinden, die solange läuft, bis alle Zellen ohne Bomben aufgedeckt wurden, der Spieler eine Bombe "aufgedeckt" oder fälschlicherweise eine Zelle als Bombe markiert hat oder das Spiel abgebrochen wurde. Auch die Ausgaben an den Benutzer (s.u.) sollen soweit möglich hier erfolgen.
Alle sinnvoll auszugliedernden Tätigkeiten sollen in Funktionen bzw. Prozeduren ausgelagert werden. Das Hauptprogramm wird dadurch relativ kurz (in der Musterlösung hat es nur ca. 60 Zeilen).

Folgende Funktionen/Prozeduren sind von Euch zu erstellen:
procedure initField(var field : TField; var visible : TVisible);
Initialisiert das Feld leer und das Sichtbarkeitsfeld mit "false". Setzt zusätzlich in (gerundet) 10% aller Zellen eine Bombe. Um hier zufällige Positionen zu bekommen, ist die Funktion random (zusammen mit randomize) hilfreich. Achtet darauf, eine Bombe nicht in einer Zelle zu platzieren, wo vorher schon eine andere Bombe gelegt wurde!

function isValidCoord(x, y : integer) : boolean;
Prüft, ob eine Koordinate gültig ist (also entsprechend des Teilbereichstyps im Feld liegt).

function countBombs(field : TField; x, y : TSize) : byte;
Gibt zurück, wie viele Bomben sich auf den (maximal) 8 Nachbarzellen der übergebenen Koordinate befinden.
Wichtig: Es ist hier NICHT erlaubt, 8x nahezu denselben Quellcode für die 8 Nachbarzellen redundant zu erstellen, sondern es soll eine einheitliche Lösung in EINER Schleife programmiert werden (siehe Hlife).

procedure printField(field : TField; visible : TVisible);
Gibt das Spielfeld in der Konsole aus (siehe Hilfe und nächster Hauptaufzählungspunkt).

function readInput(var x, y : TSize; var cancel, bomb : boolean) : boolean;
Liest vom Benutzer Spalte und Zeile (oder 'x' für Abbruch) ein und validiert diese Eingaben (prüft also, ob es sich um ganze Zahlen aus dem erlaubten Bereich handelt). Danach wird noch eingelesen, ob eine Bombe markiert (mittels b/B) oder aufgedeckt werden soll (leerer String als Eingabe). Auch hier kann mit x/X abgebrochen werden.
In cancel steht danach also, ob der Nutzer mit 'x' abgebrochen hat, die Funktionsrückgabe gibt an, ob x und y eine gültige Koordinate bilden und auch für das Markieren bzw. Aufdecken der Bombe einer der erlaubten Werte eingegeben wurde.
In bomb steht danach, ob der Spieler an der eingegebenen Koordinate eine Bombe markieren möchte (true) oder aufdecken will (false).
In dieser Funktion soll keine Schleife verwendet werden. Gibt der Nutzer etwas "falsches" ein, wodurch eine erneute Eingabe erforderlich ist, dann soll diese Wiederholung (sprich: Schleife mit erneutem Aufruf der readInput) aus dem Hauptprogramm kommen.

function isFieldSolved(field : TField; visible : TVisible) : boolean;
Prüft, ob das gesamte Spielfeld mit Ausnahme der Bomben aufgedeckt ist.
Die Ausgabe soll jeweils in der oberen linken Ecke der Konsole erfolgen, so daß sich das Feld quasi immer wieder selbst überschreibt (siehe Hilfe).
Noch nicht aufgedeckte Zellen sollen als hellgrauer ▓ ausgegeben werden (Ihr könnt das Zeichen direkt von hier in den Quellcode kopieren).
Aufgedeckte Zellen bekommen entweder ein Leerzeichen (falls in keiner der Nachbarzellen eine Bombe ist), eine farbige Zahl von 1 bis 8 (wenn mindestens eine Nachbarzelle eine Bombe beinhaltet) oder das Zeichen ð für eine (markierte) Bombe.
Zum Setzen der Textfarbe verwendet bitte die Prozedur setTextColor aus der Hilfe. Die benötigten Farbwerte sind 7 (hellgrau für verdeckte Zellen), 15 (weiß für die Bombe), 9/2/12/1/4/3/15/15 (für die Zahlen von 1 bis 8).
Deckt der Nutzer eine Zelle auf, die quasi eine 0 beinhaltet (bei der sich also auf keiner der 8 Nachbarzellen eine Bombe befindet), dann sollen vom Programm die 8 Nachbarzellen (soweit vorhanden und nicht außerhalb des Spielfeldes) direkt mit aufgedeckt werden. Dieses "automatische Aufdecken" soll allerdings NICHT rekursiv für die dadurch aufgedeckten Zellen wiederholt werden.
Wichtig: Es ist hier NICHT erlaubt, 8x nahezu denselben Quellcode für die 8 Nachbarzellen redundant zu erstellen, sondern es soll eine einheitliche Lösung in EINER Schleife programmiert werden (siehe Hlife).
Alle Textausgaben zur Information der Spieler wie "Ungültige Angabe" oder "Spiel abgebrochen" sollen unter dem Spielfeld ausgegeben werden. Versucht, den Spieler mit möglichst detaillierten (Fehler-)Meldungen gut durch das Spiel zu führen.
Das Programm darf keinesfalls abstürzen, egal, was der Benutzer eingibt. Auch bei Buchstaben/Strings, zu großen/kleinen Zahlen oder dem leeren String als Angabe für die Spalte oder Zeile muß das Programm also z.B. (nach Ausgabe einer Fehlermeldung) normal weiterlaufen!
Hier hilft Euch die vordefinierte Prozedur val weiter (siehe Wichtige Prozeduren und Funktionen).
Achtet besonders bei dieser Aufgabe auf korrekt gesetzte Compilerschalter ($R+ für Bereichsüberprüfungen), denn vor allem beim countBombs läuft man sonst schnell mal aus dem Feld hinaus! Denkt weiterhin daran, daß keine Techniken eingesetzt werden dürfen, die in der Übung noch nicht behandelt wurden!
Außerdem soll an allen sinnvollen Stellen der Teilbereichstyp benutzt werden (und eben z.B. nicht eine for-Schleife von 1 bis SIZE). Dazu sind low und high zu benutzen. Das Programm muß also auch dann noch richtig arbeiten, wenn die Konstante verändert wird!



Ich bin jetzt bei der Procedure initField stehen geblieben da ich nicht verstehe wie ich randomize mit einem zweidimensionalen Array nutzen kann.

Außerdem wird auch nicht das verdeckte Spielfeld ausgegeben wenn ich dies versuche, sondern eine Fehlermeldung bei der Bereichsprüfung.

Delphi-Quellcode:

program Uebung_7;

{$APPTYPE CONSOLE}

{$R+,Q+,X-}

uses
  System.SysUtils, Windows;

const
  FIELDSIZE : Byte = 7;

type
  TSize = 1..7;
  TSTATE = (leer, Bombe);
  TDIR = (Nord, NordOst, Ost, SüdOst, Süd, SüdWest, West, NordWest);
  TFIELD = array[TSIZE, TSIZE] of TSTATE;
  TVISIBLE = array[TSIZE, TSIZE] of Boolean;

const
  OFFSET_X : array[TDIR] of integer = (0,1,1,1,0,-1,-1,-1);
  OFFSET_Y : array[TDIR] of integer = (1,1,0,-1,-1,-1,0,1);

//Setzt die Ausgabeposition der Konsole auf die angegebene Koordinate.
//@param
//x,y - zu setzende Position in der Konsole an 0/0 = oben links
procedure setConsolePosition(x,y : byte);
var
  coord : _COORD;
  begin
    coord.X := x;
    coord.Y := y;
    if SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord) then;
  end;

//Setzt die Textfarbe der Konsole
//@param
//color - zu setzender Farbwert
procedure setTextColor(color : word);
begin
  if SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), color) then
end;

//Initialisiert das Feld leer und das Sichbarkeitsfeld mit 'false'
//Setzt in gerundet 10% aller Zellen eine Bombe
//@param
//field - Feld, welches initialisiert wird
//visible - zu setzendes Sichtbarkeitsfeld
procedure initField(var field : TFIELD ; var visible : TVISIBLE);
var x, y, i, r, s, run : integer;
begin
   for x := 1 to FIELDSIZE do
   begin
    for y := 1 to FIELDSIZE do
    begin
      visible[x, y] := FALSE;
      field[x,y] := leer;
    end;
   end;
   r := (FIELDSIZE * FIELDSIZE) div 10;
   s := (FIELDSIZE * FIELDSIZE) mod 10;
   if s >= 5 then inc(r);
   //Bomben platzieren
   for run := 1 to r do
   begin
    (* randomize;
     i := random(field[x, y]);  *)
     //TODO
   end;
 end;

//Prüft, ob eine Koordinate gültig ist
//@param
// x,y - zu überprüfende Koordinatenwerte
//@out
//Überprüfung ob Koordinate im Bereich des Spielfeldes liegt
//@return
// true, wenn Koordinaten gültig sind
function isValidCoord(x,y : integer): boolean;
begin
  if ((x <= FIELDSIZE) and (x >= 1)) then
  if ((y <= FIELDSIZE) and (y >= 1)) then
  isValidCoord := TRUE
  else isValidCoord := FALSE;
end;

//Zeigt an, wie viele Bomben sich auf den Nachbarzellen, der übergebenen
//Koordinate befinden
//@param
//field - Spielfeld, welches geprüft wird
//x,y - Koordinaten
//@out
//
//@return
// byte-Wert, wie viele Bomben in den Nachbarzellen existieren



//Textausgabe des Spielfeldes in der Konsole
//@param
//field - Spielfeld, welches ausgegeben werden soll
//visible - augedeckte Zellen
procedure printField(field : TFIELD ; visible : TVISIBLE);
var
  x, y : byte;
begin
  x := 1;
  y := 1;
  repeat
  repeat
    if visible[x,y] = FALSE then
    write('▓');
    inc(x);
  until x = FIELDSIZE + 1 ;
  writeln;
  if visible[x,y] = FALSE then
  write('▓');
  inc(y);
  until y = FIELDSIZE +1;
end;

var
  field :TFIELD;
  visible : TVISIBLE;
begin
  initField(field,visible);
  printField(field,visible);
  readln;
end.

Bin über jede Hilfe sehr Dankbar

[Sinspin]

Randomize schon garnicht. Das wird nur einmal außerhalb der Schleife aufgerufen.
Und Random kannst du auch mit einem 10-dimensionalen Array verwenden.

Schau nochmal in die Hilfe was Random macht.

[Blup]

Eigentlich ist die Projektbeschreibung schon zu detailiert.

Delphi-Quellcode:

   //Bomben platzieren
   while r > 0 do
   begin
     x := Random(FIELDSIZE) + 1; // Random liefert einen Wert 0..(FIELDSIZE - 1)
     y := Random(FIELDSIZE) + 1;
     if field[x, y] = leer then
     begin
       field[x, y] := Bombe;
       Dec(r);
     end;
   end;

Delphi-Quellcode:

procedure printField(field : TFIELD; visible : TVISIBLE);
var
  x, y : byte;
  s: string;
  n: Integer;
begin
  for x := 1 to FIELDSIZE do
  begin
    for y := 1 to FIELDSIZE do
    begin
      if not visible[x, y] then
        s := '▓'
      else if field[x, y] = Bombe then
        s := 'ð'
      else
      begin
        n := countBombs(field, x, y);
        if n = 0 then
          s := ' '
        else
          s := IntToStr(n);
      end;
      write(s);
    end;
    writeln;
  end;
end;

Natürlich sind da noch weitere Anforderungen in der Projektbeschreibung, die zu berücksichtigen sind.

[Mo53]

Das habe ich jetzt nicht ganz verstanden ?
Muss randomize;
random(...

nicht immer vor Random stehen ?

[Sinspin]

Eigentlich brauchst Du überhaupt kein Randomize. Es nimmt dir nur arbeit ab.
Randomize legt einen Wert für die globale Variable RandSeed fest. Der Wert wird on der Funktion Random verwendet um Zufallszahlen zu erzeugen.
Willst du immer die gleichen Zufallszahlen, dann legst Du beim Programmstart RandSeed selber fest. Ansonsten rufst Du einmal beim Programmstart Randomize auf.

[Michael II]

Delphi erzeugt ausgehend von einem Zustand (integer Startwert) Pseudozufallszahlen nach einem festen Muster.

Mit randomize; erzeugst du einen pseudozufälligen Zustand/Startwert.
(Alternativ kannst du mit randseed := .. einen Startwert setzen.)

Mit random(x) kannst du danach Pseudozufallszahlen im Intervall [0..x-1] erzeugen lassen.

Für deine Anwendung reicht es, wenn du genau einmal - zum Beispiel beim Start des Programms randomize; aufrufst. (...oder wenn du willst immer beim Start eines neuen Spiels.)
___________________________________________

Tipp: Anstatt mit randomize; einen pseudozufälligen Zustand/Startwert zu setzen, kannst du mit randseed einen Wert setzen:

Wenn du zum Beispiel randseed := 190391 wählst und danach mittels random(10) Zufallszahlen im Bereich 0..9 erzeugen lässt, dann erzeugt dein Programm auf jedem Computer immer die gleiche Folge von Zufallszahlen 4 4 5 3 4 6 7 5 9 3 2...

Angewendet auf (d)ein Spiel: Du kannst beim Spielstart die Spielerin fragen, welche Spielnummer (sn) sie gerne spielen möchte. - Anstatt mit randomize einen zufälligen Startwert zu erzeugen setzt du in deinem Programm randseed := sn;. Die gleiche Nummer führt dann überall immer zum gleichen Spielfeld.

Das kann spannend sein, wenn Xaver meint, Spiel 2901 sei echt schwer und andere einladen will, es auch zu versuchen.
___________________________________________

[himitsu]

Randomize wird einmal aufgerufen, um den PseudoZufallsgenerator zu initialisieren.

In einer ConsolenAnwendung ruft man das selber auf, zu Beginn.
In der VCL kann es inzwischen weggelassen werden, da die VCL es initialisiert. (k.A. warum man das in der VCL macht, anstatt einheitlich für Alles in der RTL ... und man kann es immernoch selber machen, wenn man unbedingt will)

Vor jedem Random/RandomRange ein Randomize funktioniert "inzwischen", aber
* vor Jahren wurde noch GetTickCount zur Initialisierung verwendet, womit mehrere Randomize in kurzer Zeit mit dem selben Wert initialisierten
* und auch wenn es jetzt "scheinbar" möglich ist, hat man hier dennoch das Problemchen, dass die generierten Zufallszahlen wahrscheinlich nicht gleichverteilt sind, womit es "ungünstige" Häufungen geben kann

[Mo53]

Alles Klar, Vielen Dank für die umfangreichen Erklärungen

[Mo53]

Ich hab hier noch ein Problem mit der Funktion readInput.
Und zwar bleibt readInput immer false auch wenn gueltig := true oder cancel := true ist

Delphi-Quellcode:

{$APPTYPE CONSOLE}
{$R+,Q+,X-}

uses
  System.SysUtils,
  Windows;

const
  FIELDSIZE: Byte = 7;

type
  TSize = 1 .. 7;
  TSTATE = (leer, Bombe);
  TDIR = (Nord, NordOst, Ost, SüdOst, Süd, SüdWest, West, NordWest);
  TFIELD = array [TSize, TSize] of TSTATE;
  TVISIBLE = array [TSize, TSize] of Boolean;

const
  OFFSET_X: array [TDIR] of integer = (0, 1, 1, 1, 0, -1, -1, -1);
  OFFSET_Y: array [TDIR] of integer = (1, 1, 0, -1, -1, -1, 0, 1);

  // Setzt die Ausgabeposition der Konsole auf die angegebene Koordinate.
  // @param
  // x,y - zu setzende Position in der Konsole an 0/0 = oben links
procedure setConsolePosition(x, y: Byte);
var
  coord: _COORD;
begin
  coord.x := x;
  coord.y := y;
  if SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), coord) then;
end;

// Setzt die Textfarbe der Konsole
// @param
// color - zu setzender Farbwert
procedure setTextColor(color: word);
begin
  if SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), color) then
end;

// Initialisiert das Feld leer und das Sichbarkeitsfeld mit 'false'
// Setzt in gerundet 10% aller Zellen eine Bombe
// @param
// field - Feld, welches initialisiert wird
// visible - zu setzendes Sichtbarkeitsfeld
procedure initField(var field: TFIELD; var visible: TVISIBLE);
var
  x, y, r, s: integer;
begin
  for x := 1 to FIELDSIZE do
  begin
    for y := 1 to FIELDSIZE do
    begin
      visible[x, y] := FALSE;
      field[x, y] := leer;
    end;
  end;
  r := (FIELDSIZE * FIELDSIZE) div 10;
  s := (FIELDSIZE * FIELDSIZE) mod 10;
  if s >= 5 then
    inc(r);
  // Bomben platzieren
  randomize;
  while r > 0 do
  begin
    x := Random(FIELDSIZE) + 1; // Random liefert einen Wert 0..(FIELDSIZE - 1)
    y := Random(FIELDSIZE) + 1;
    if field[x, y] = leer then
    begin
      field[x, y] := Bombe;
      Dec(r);
    end;
  end;
end;

// Prüft, ob eine Koordinate gültig ist
// @param
// x,y - zu überprüfende Koordinatenwerte
// @out
// Überprüfung ob Koordinate im Bereich des Spielfeldes liegt
// @return
// true, wenn Koordinaten gültig sind
function isValidCoord(x, y: integer): Boolean;
begin
  if ((x <= FIELDSIZE) and (x >= 1)) then
    if ((y <= FIELDSIZE) and (y >= 1)) then
      isValidCoord := TRUE
    else
      isValidCoord := FALSE;
end;

// Zeigt an, wie viele Bomben sich auf den Nachbarzellen, der übergebenen
// Koordinate befinden
// @param
// field - Spielfeld, welches geprüft wird
// x,y - Koordinaten
// @out
// Bestimmung der Nachbarzellen
// @return
// byte-Wert, wie viele Bomben in den Nachbarzellen existieren
function countBombs(field: TFIELD; x, y: TSize): Byte;
var
  dir: TDIR;
  xNachbar, yNachbar: integer;
  n: Byte;
begin
  n := 0;
  for dir := low(TDIR) to high(TDIR) do
  begin
    xNachbar := x + OFFSET_X[dir];
    yNachbar := y + OFFSET_Y[dir];
    if field[x, y] = Bombe then
      inc(n);
  end;
  countBombs := n;
end;

// Textausgabe des Spielfeldes in der Konsole
// @param
// field - Spielfeld, welches ausgegeben werden soll
// visible - augedeckte Zellen
procedure printField(field: TFIELD; visible: TVISIBLE);
var
  x, y: Byte;
  s: string;
  n: integer;
begin
  for x := 1 to FIELDSIZE do
  begin
    for y := 1 to FIELDSIZE do
    begin
      if not visible[x, y] then
        s := '▓'
      else if field[x, y] = Bombe then
        s := 'ð'
      else
      begin
        n := countBombs(field, x, y);
        if n = 0 then
          s := ' '
        else
          s := IntToStr(n);
      end;
      write(s, ' ');
    end;
    writeln;
  end;
end;

// liest vom Benutzer Spalte und Zeile ein und prüft diese. Außerdem wird der
// Benutzer gefragt ob die gewählte Zelle aufgedeckt oder als Bombe markiert
// oder das Programm mit der Eingabe von x beendet werden soll
// @param
// x,y - x- und y-Koordinate des Spielfeldes
// cancel - soll das Spiel verlassen werden?
// bomb - soll eine Bombe markiert werden?
// @out
//
// @return
function readInput(var x, y: TSize; var cancel, bomb: Boolean): Boolean;
var
  eingabe: char;
  gueltig: Boolean;
begin
  eingabe := upcase(eingabe);
  gueltig := FALSE;
  case eingabe of
    'X':
      cancel := TRUE;
    '1' .. '7':
      gueltig := TRUE;
  end;

  case eingabe of
    'X':
      cancel := TRUE;
    'B':
      bomb := TRUE;
  end;
  readInput := gueltig or cancel;
end;

// Prüft, ob das gesamte Spielfeld mit Ausnahme der Bomben aufgedeckt ist
// @param
// field - Spielfeld, in dem geprüft werden soll
// visible -Sichtbarkeit der Zellen
// @out
//
// @return
// true, wenn alle Zellen außer die Bomben aufgedeckt sind
(* function isFieldSolved(field : TFIELD; visible :TVISIBLE) : boolean;
  begin
  while visible or (field = Bombe) do

  end; *)

var
  field: TFIELD;
  visible: TVISIBLE;
  cancel, bomb: Boolean;
  x, y: TSize;

begin
  initField(field, visible);
  printField(field, visible);
  writeln('Bitte eine Spalte von 1 bis 7 eingeben oder ''X'' für Abbruch: ');
  readln(x);
  if readInput(x, y, cancel, bomb) then
  begin
    writeln('Bitte eine Zeile von 1 bis 7 eingeben oder ''X'' für Abbruch: ');
    readln(y);
    if readInput(x, y, cancel, bomb) then
    begin
      writeln('Bitte ein ''B'' eingeben, wenn dort eine Bombe markiert werden soll, '
        + 'leer lassen zum aufdecken oder ''X'' für Abbruch: ');
    end;
  end;

  readln;

end.

[Michael II]

Ich frage mich, wieso du das hier kompilieren kannst: eingabe := upcase(eingabe); ? Mein Delphi könnte das nicht .

Wenn du in #1 deine Beschreibung von function readInput(var x, y: TSize; var cancel, bomb: Boolean): Boolean; liest, dann könnte man vermuten, dass die Benutzereingaben Spalte, Zeile etc. direkt IN der Funktion eingelesen werden sollten und nicht im Hauptprogramm. (Darauf deutet auch hin, dass die Argumente als var Parameter deklariert sind.).