1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:
175:
176:
177:
178:
179:
180:
181:
182:
183:
184:
185:
186:
187:
188:
189:
190:
191:
192:
193:
194:
195:
196:
197:
198:
199:
200:
201:
202:
203:
204:
205:
206:
207:
208:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls, ExtCtrls;

type
  TForm1 = class(TForm)
    Panel1: TPanel;
    Panel2: TPanel;
    Button1: TButton;
    procedure FormCreate(Sender: TObject);
    procedure Button1Click(Sender: TObject);
  private
    { Private-Deklarationen }
    procedure PanelClick(Sender: TObject);
    procedure ErstelleFelder(Panel: TPanel; MatrixNr: Integer);
    procedure AufPanelMatrixAnzeigen(Panel: String; MatrixNr: Integer);
  public
    { Public-Deklarationen }
  end;

type
  TSchiffeMatrix = record
    xy: array[0..9, 0..9] of Shortint;
  end;

var
  Form1: TForm1;
  Matrix: array[1..2] of TSchiffeMatrix;

implementation

{$R *.DFM}


procedure TForm1.PanelClick(Sender: TObject);
var
  l, x, y, i, z: Integer;
  s: String;
  p: Byte;
begin
  l := Length(TPanel(Sender).Name);
  s := TPanel(Sender).Name;
  x := StrToInt(s[l-1]);
  y := StrToInt(s[l]);

  p := TPanel(Sender).Tag;
  if Matrix[p].xy[x, y] > 0 then
  begin
    TPanel(Sender).Color := clRed;
    Matrix[p].xy[x, y] := -Matrix[p].xy[x, y];
  end;

  for i := -1 downto -5 do
  begin
    z := 0;

    for x := 0 to 9 do for y := 0 to 9 do
      if Matrix[p].xy[x, y] = i then inc(z);

    if z = Abs(i) then
      for x := 0 to 9 do for y := 0 to 9 do
        if Matrix[p].xy[x, y] = -z then
          with TPanel(FindComponent('Panel'+IntToStr(p))) do
            TPanel(FindComponent('Panel'+IntToStr(p)+intToStr(x)+IntToStr(y))).Color := clBlack;
  end;

end;

procedure TForm1.ErstelleFelder(Panel: TPanel; MatrixNr: Integer);
var
  x, y: Integer;
  h, w: Integer;
begin
  w := Panel.Width div 10;
  h := Panel.Height div 10;

  for y := 0 to 9 do
    for x := 0 to 9 do
    begin
      with TPanel.Create(Panel) do
      begin
        Parent := Panel;
        Width := h;
        Height := w;
        Left := x * Width;
        Top := y * Height;
        Name := TPanel(Panel).Name + IntToStr(x) + IntTostr(y);
        Caption := '';
        Tag := MatrixNr;
        OnClick := PanelClick;
      end;
    end;
end;

procedure SchiffZufaelligPositionieren(Schifflaenge: Integer; MatrixNr: Integer);
var
  Gesetzt: Boolean;
  Neustart: Boolean;
  x, y, ix, iy, Richtung: integer;
begin
  Randomize;

  repeat
    // da random 0 <= x < 1, muß x immer eins höher sein, d.h. + 1
    Richtung := Random(1 + 1); // richtung 0 wagerecht 1 senkrecht

    Gesetzt := False;
    Neustart := False;

    case Richtung of
      0: begin  // wagerecht
           x := Random(9 + 1 - Schifflaenge);
           y := Random(9 + 1);

           for ix := x to x + Schifflaenge-1 do
             if Matrix[MatrixNr].xy[ix, y] <> 0 then Neustart := True;
           if Neustart then Continue;

           for ix := x to x + Schifflaenge-1 do
             Matrix[MatrixNr].xy[ix, y] := Schifflaenge;

           Gesetzt := True;
         end;
      1: begin  // senkrecht
           x := Random(9 + 1);
           y := Random(9 + 1 - Schifflaenge);

           for iy := y to y + Schifflaenge-1 do
             if Matrix[MatrixNr].xy[x, iy] <> 0 then Neustart := True;
           if Neustart then Continue;

           for iy := y to y + Schifflaenge-1 do
             Matrix[MatrixNr].xy[x, iy] := Schifflaenge;

           Gesetzt := True;
         end;
    end;
  until Gesetzt;

end;

procedure TForm1.AufPanelMatrixAnzeigen(Panel: String; MatrixNr: Integer);
var
  x, y: integer;
  sName: String;
begin
  // auf Panel übertragen
  with TPanel(FindComponent(Panel)) do
    for x := 0 to 9 do for y := 0 to 9 do
    begin
      sName := Panel + IntToStr(x) + IntToStr(y);

      if Matrix[MatrixNr].xy[x, y] = 0 then
        TPanel(FindComponent(sName)).Caption := ''
      else
        TPanel(FindComponent(sName)).Caption := IntToStr(Matrix[MatrixNr].xy[x, y]);
    end;
end;

procedure PanelMatrix(Panel: String; MatrixNr: Integer);
var
  x, y, Schifflaenge: integer;
begin
  // standardfarbe setzen
  for x := 0 to 9 do for y := 0 to 9 do
    with Form1, TPanel(FindComponent(Panel)) do
      TPanel(FindComponent(Panel+IntToStr(x)+IntToStr(y))).Color := clBtnFace;

  Randomize;

  // matrix vorher leeren
  for x := 0 to 9 do for y := 0 to 9 do Matrix[MatrixNr].xy[x, y] := 0;

  // alle fünf schiffsarten erstellen
  for Schifflaenge := 5 downto 1 do SchiffZufaelligPositionieren(Schifflaenge, MatrixNr);

  Form1.AufPanelMatrixAnzeigen(Panel, MatrixNr);
end;


procedure PanelMatrix1;
begin
  PanelMatrix('Panel1', 1);
end;

procedure PanelMatrix2;
begin
  PanelMatrix('Panel2', 2);
end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  ErstelleFelder(Panel1, 1);
  ErstelleFelder(Panel2, 2);
end;

procedure TForm1.Button1Click(Sender: TObject);
begin
  PanelMatrix1;
  Sleep(10); // Kurze Pause, sonst haben beide Felder die gleichen Werte. Keine Ahnung warum.
  PanelMatrix2;
end;

end.					

1:

Array [0..9,0..9] Of Char;					

1:
2:
3:

Type
  TZelle = (zeUnbekannt, zeWasser, zeSchiffRot, zeSchiffSchwarz);
  TSpielfeld = Array [0..9,0..9] of TZelle;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:

procedure TForm1.StringGrid1DrawCell(Sender: TObject; ACol, ARow: Integer;
  Rect: TRect; State: TGridDrawState);
begin
  with Stringgrid1 do
    begin
      if ARow mod 2 = 0 then
        begin
          Canvas.Brush.Color := clRed;
          Canvas.TextRect(Rect, Rect.Left + 2, Rect.Top + 2, Cells[Acol, Arow]);
        end;
    end;
end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
  StdCtrls, ExtCtrls;

type
  TForm1 = class(TForm)
    Image1: TImage;
    Image2: TImage;
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
    procedure Image1MouseUp(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
    procedure FormCreate(Sender: TObject);
    procedure Image2MouseUp(Sender: TObject; Button: TMouseButton;
      Shift: TShiftState; X, Y: Integer);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.DFM}

uses
  uAllgemeinTeil, uFeld, uMatrix;

procedure TForm1.FormCreate(Sender: TObject);
begin
  ZweiLeereAnfangsFelderZeichnen(Image1, Image2);
end;

// Hier wird X/Y (Image1) ermittelt und ausgewertet
procedure TForm1.Image1MouseUp(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
  FeldKlicksAuswerten(Image1.Picture.Bitmap, 1, x, y);
end;

// Hier wird X/Y (Image2) ermittelt und ausgewertet
procedure TForm1.Image2MouseUp(Sender: TObject; Button: TMouseButton;
  Shift: TShiftState; X, Y: Integer);
begin
  FeldKlicksAuswerten(Image2.Picture.Bitmap, 2, x, y);
end;

// Hier Matrix mit Schiffen füllen und Zeichen
procedure TForm1.Button1Click(Sender: TObject);
begin
  SpielNeu(Image1, Image2);;
end;

end.					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:

unit uAllgemeinTeil;

interface

uses
  extctrls;

    procedure ZweiLeereAnfangsFelderZeichnen(Image1, Image2: TImage);
    procedure SpielNeu(Image1, Image2: TImage);

implementation

uses
  uMatrix, uFeld;

// Für den Anfang zuerst zwei zwei leere Felder zeichen. Diese Funktion muß
// in Crate-Teil des Spiels aufgerufen werden um die Bitmapgrößen zu setzten.
procedure ZweiLeereAnfangsFelderZeichnen(Image1, Image2: TImage);
begin
  MatrixLeeren(1);
  MatrixLeeren(2);

  with Image1.Picture do
  begin
    Bitmap.Width := Image1.Width;
    Bitmap.Height := Image1.Height;
    FelderNachMatrixZeichen(Bitmap, FELDER_X, FELDER_Y, True, 1);
  end;

  with Image2.Picture do
  begin
    Bitmap.Width := Image2.Width;
    Bitmap.Height := Image2.Height;
    FelderNachMatrixZeichen(Bitmap, FELDER_X, FELDER_Y, True, 2);
  end;
end;

// Hier Matrix mit Schiffen füllen und Zeichen
procedure SpielNeu(Image1, Image2: TImage);
begin
  //FuenfSchiffeInMatrixZufaelligPositionieren(1);
  //FuenfSchiffeInMatrixZufaelligPositionieren(2);

  BeideMatrixFelderMitSchiffenFuellen;

  FelderNachMatrixZeichen(Image1.Picture.Bitmap, FELDER_X, FELDER_Y, True, 1);
  FelderNachMatrixZeichen(Image2.Picture.Bitmap, FELDER_X, FELDER_Y, True, 2);
end;

end.					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:
155:
156:
157:
158:
159:
160:
161:
162:
163:
164:
165:
166:
167:
168:
169:
170:
171:
172:
173:
174:

unit uMatrix;

interface

uses
  Windows;

  procedure MatrixLeeren(MatrixNr: Integer);
  procedure FeldInVirtuellenZehnerMatrixErmitteln(var a: Integer; var b: Integer;
    x, y, BmpWidth, BmpHeight: Integer);
  procedure PruefenObSchiffGetroffenWurde(MatrixNr, MatrixX, MatrixY: Integer);
  function GesunkeneSchiffeErmitteln(MatrixNr: Integer): Boolean;
  procedure FuenfSchiffeInMatrixZufaelligPositionieren(MatrixNr: Integer);
  procedure BeideMatrixFelderMitSchiffenFuellen;

const
  FELDER_X = 15;
  FELDER_Y = 15;

type
  TSchiffeMatrix = record
    xy: array[0..FELDER_X-1, 0..FELDER_Y-1] of Shortint;
  end;

var
  Matrix: array[1..2] of TSchiffeMatrix;

implementation


// Überschreibt alle Werte in Array mit 0
procedure MatrixLeeren(MatrixNr: Integer);
var
  x, y: Integer;
begin
  for x := 0 to FELDER_X - 1 do for y := 0 to FELDER_Y - 1 do
    Matrix[MatrixNr].xy[x, y] := 0;
end;

// Berechnet anhand des X/Y Pixels und Bitmapgröße das X/Y Feld im Arry
// Lokale Prozedur
procedure FeldInVirtuellenMatrixErmitteln(var a: Integer; var b: Integer;
  x, y, BmpWidth, BmpHeight, FelderX, FelderY: Integer);
begin
  a := (x * FelderX div BmpWidth) - 1;
  if ((x * FelderX) mod BmpWidth) > 0 then Inc(a);

  b := (y * FelderY div BmpHeight) - 1;
  if ((y * FelderY) mod BmpHeight) > 0 then Inc(b);
end;

// Ruft die obere Prozedur mit FELDER_X und FELDER_Y Werten
procedure FeldInVirtuellenZehnerMatrixErmitteln(var a: Integer; var b: Integer;
  x, y, BmpWidth, BmpHeight: Integer);
begin
  FeldInVirtuellenMatrixErmitteln(a, b, x, y, BmpWidth, BmpHeight, FELDER_X, FELDER_Y);;
end;

// Hier wird geprüft ob ein Schiffteil getroffen wurde. Wenn Ja, dann wird
// Wert in Matrix negiert und so als getroffen merkiert.
procedure PruefenObSchiffGetroffenWurde(MatrixNr, MatrixX, MatrixY: Integer);
begin
  if Matrix[MatrixNr].xy[MatrixX, MatrixY] > 0 then
    Matrix[MatrixNr].xy[MatrixX, MatrixY] := -Matrix[MatrixNr].xy[MatrixX, MatrixY];
end;

// Hier wird geprüft ob alle Felder eines Schiffes getroffen wurden.
// Wenn ja, dann wird in der Matrix ein Schiff-Versenkt-Wert gespeichert.
// Beispiel: Ein 5'er Schiff besteht aus 5'er Zahlen in der Matrix.
// Ist ein 5'er Teil getroffen, dann wird der Wert negiert, z.B. -5
// Sind alle Teile des Sch. getroffen, dann werden alle 5'er Wert um
// 10 regiziert, d.h. -15. Alle Werte unter -10 sind gesunkene Schiffe.
// Lokale Funktion
function GesunkeneSchiffe(MatrixNr, FelderX, FelderY: Integer): Boolean;
var
  i, x, y, z: Integer;
begin
  for i := -1 downto -5 do
  begin
    z := 0;

    // Hier ermitteln wieviel eines Schiffes getroffen ist
    for x := 0 to FelderX - 1 do for y := 0 to FelderY - 1 do
      if Matrix[MatrixNr].xy[x, y] = i then inc(z);

    // Wenn alle, dann sinken lassen.
    // Hier Felder markieren in dem sie < -10 sind.
    if z = Abs(i) then
    begin
      for x := 0 to FelderX - 1 do for y := 0 to FelderY - 1 do
        if Matrix[MatrixNr].xy[x, y] = -z then
          Matrix[MatrixNr].xy[x, y] := Matrix[MatrixNr].xy[x, y] -10;
    end;
  end;

  Result := False; // Reserviert
end;

// Ruft die obere Funktion mit FELDER_X und FELDER_Y Werten
function GesunkeneSchiffeErmitteln(MatrixNr: Integer): Boolean;
begin
  Result := GesunkeneSchiffe(MatrixNr, FELDER_X, FELDER_Y);
end;

// Hier wird ein Schiff per Zufall in die Matrix positioniert und gleich
// überprüft ob es kein andereres Schiff kreuzt.
// Lokale Prozedur
procedure EinSchiffInMatrixZufaelligPositionieren(FelderX, FelderY: Integer;
  Schifflaenge: Integer; MatrixNr: Integer);
var
  Gesetzt: Boolean;
  Neustart: Boolean;
  x, y, x2, y2, Richtung: integer;
begin
  Randomize;

  repeat // versuch und prüfung
    // da random 0 <= x < 1, muß x immer eins höher sein, d.h. + 1
    Richtung := Random(1 + 1); // richtung 0 wagerecht 1 senkrecht

    Gesetzt := False;
    Neustart := False;

    case Richtung of
      0: begin  // schiff wagerecht positionieren
           x := Random((FelderX - 1) + 1 - Schifflaenge);
           y := Random((FelderY - 1) + 1);

           for x2 := x to x + Schifflaenge-1 do
             if Matrix[MatrixNr].xy[x2, y] <> 0 then Neustart := True;
           if Neustart then Continue;

           for x2 := x to x + Schifflaenge-1 do
             Matrix[MatrixNr].xy[x2, y] := Schifflaenge;

           Gesetzt := True;
         end;
      1: begin  // schif senkrecht positionieren
           x := Random((FelderX - 1) + 1);
           y := Random((FelderY - 1) + 1 - Schifflaenge);

           for y2 := y to y + Schifflaenge-1 do
             if Matrix[MatrixNr].xy[x, y2] <> 0 then Neustart := True;
           if Neustart then Continue;

           for y2 := y to y + Schifflaenge-1 do
             Matrix[MatrixNr].xy[x, y2] := Schifflaenge;

           Gesetzt := True;
         end;
    end;
  until Gesetzt;
end;

// Ruft die obere Prozedur für alle fünf Schifarten
procedure FuenfSchiffeInMatrixZufaelligPositionieren(MatrixNr: Integer);
var
  Schifflaenge: integer;
begin
  MatrixLeeren(MatrixNr);

  for Schifflaenge := 5 downto 1 do
    EinSchiffInMatrixZufaelligPositionieren(FELDER_X, FELDER_Y, Schifflaenge, MatrixNr);
end;

// Ruft die obere Prozudur für beide Matrix-Felder.
procedure BeideMatrixFelderMitSchiffenFuellen;
begin
  FuenfSchiffeInMatrixZufaelligPositionieren(1);
  Sleep(100); // Kurze Pause, sonst haben beide Felder die gleichen Werte. Keine Ahnung warum.
  FuenfSchiffeInMatrixZufaelligPositionieren(2);
end;

end.					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:

unit uFeld;

interface

uses
  Graphics, Dialogs;

  //procedure ZehnMalZehnMatixFeldZeichen(Bitmap: TBitmap; Cl3D: Boolean);
  procedure FelderNachMatrixZeichen(Bitmap: TBitmap; xm, ym: Integer; Cl3D: Boolean; MatrixNr: Integer);
  function FeldKlicksAuswerten(Bitmap: TBitmap; MatrixNr, x, y: Integer): Boolean;

implementation

uses
  uMatrix;

// Hier wird ein einziges Positionsfeld generiert und gezeichnet.
// Man kann die Höhe, Breite, Farbe und 3D Effekt wählen.
// Lokale Prozedur
procedure EinFeldZeichen(Bmp: TBitmap; w, h: Integer; Col: TColor; Cl3D: Boolean);
begin
  Bmp.Width := w;
  Bmp.Height := h;
  with Bmp.Canvas do
  begin
    Brush.Color := Col;
    Brush.Style := bsSolid;

    if not Cl3D then {Einfaches 2D Rechteck}
    begin
      Pen.Color := clBlack;
      Rectangle(0, 0, w, h);
    end
      else
    begin {3D Rechteck}
      FillRect(ClipRect); // Füllt Bereich mit Farbe
      Pen.Color := $00454545; //clGray;
      MoveTo(w-1, 0); LineTo(w-1, h-1);
      MoveTo(0, h-1); LineTo(w, h-1);
      Pen.Color := clWhite;
      MoveTo(0, 0); LineTo(w, 0);
      MoveTo(0, 0); LineTo(0, h);
    end;
  end;
end;

// Zeichnet mit der oberen "EinFeldZeichen" Prozedur ein 10 x 10 Feld in eine Bitmap.
// Dabei werden die Werte in der Array Matrix beachtet. 0 bedeutet leer,
// 1 ein 1'er Schiff, 2 ein 2'er Schiff,
// -3 ein Teil eines 3'er Schiffes das getroffen wurde,
// -14 ein teil eines 4'er Schiffes das komplett getroffen wurde und gesunken ist.
procedure FelderNachMatrixZeichen(Bitmap: TBitmap; xm, ym: Integer; Cl3D: Boolean; MatrixNr: Integer);
var
  w, h, x, y: Integer;
  a: Shortint;
  Bmp: TBitmap;
begin
  w := Bitmap.Width div xm;
  h := Bitmap.Height div ym;

  for x := 0 to xm - 1 do
    for y := 0 to ym - 1 do
    begin
      Bmp := TBitmap.Create;
      try
        a := Matrix[MatrixNr].xy[x, y];

        case a of
          0: EinFeldZeichen(Bmp, w, h, clBtnFace, Cl3D); // Kein Schiff
          //1..5: EinFeldZeichen(Bmp, w, h, clBlue, Cl3D); // Schiff 1-5
          1: EinFeldZeichen(Bmp, w, h, $00FF8080, Cl3D); // Schiff 1
          2: EinFeldZeichen(Bmp, w, h, $00C08000, Cl3D); // Schiff 2
          3: EinFeldZeichen(Bmp, w, h, $00FF8000, Cl3D); // Schiff 3
          4: EinFeldZeichen(Bmp, w, h, $00C08080, Cl3D); // Schiff  4
          5: EinFeldZeichen(Bmp, w, h, clBlue, Cl3D); // Schiff 5
          -5..-1: EinFeldZeichen(Bmp, w, h, clRed, Cl3D); // Geftroffenes Schiff
          -15..-11: EinFeldZeichen(Bmp, w, h, clBlack, Cl3D); // Schiff unter
        end;
        Bitmap.Canvas.Draw(x * w, y * h, Bmp);
      finally
        Bmp.Free;
      end;
    end;
end;

// Hier wird der Mausklick an Position X/Y berechnet, in Matrix übertragen und
// auf der Image gezeichnet. Der Rest geht über weitere Funktionen.
function FeldKlicksAuswerten(Bitmap: TBitmap; MatrixNr, x, y: Integer): Boolean;
var
  a, b: Integer;
begin
  FeldInVirtuellenZehnerMatrixErmitteln(a, b, x, y, Bitmap.Width, Bitmap.Height);
  PruefenObSchiffGetroffenWurde(MatrixNr, a, b);
  Result := GesunkeneSchiffeErmitteln(MatrixNr);
  FelderNachMatrixZeichen(Bitmap, FELDER_X, FELDER_Y, True, MatrixNr);
end;

end.