Schiffe versenken programmieren

[leodinho]

wie weiß ich jetzt aber ob ne zelle gültig ist oder nicht?
ob es im feld liegt?
also x <= maxfeld?

[Sir Rufo]

So, ich kann mir das Elend nicht mehr mit anschauen und hier ein fertiges Schiffe Versenken in einer Konsolen-Version und ohne Highscore.

Wie man sieht bleibt vom eigentlichen Spiel nicht viel mehr als Vorbereiten und SchussAuf.
Logisch, denn die Erfassung der Schusskoordinaten und Ausgabe des Spielfeldes gehört zum User-Interface und nicht zum Spiel, denn das Spiel funktioniert auch ohne User-Interface.

Es ist bewusst rudimentär gehalten ohne viel BlinkBlink um den Blick nicht vom Wesentlichen abzulenken.
Ich habe mir erlaubt keine Kommentare zu setzen, da der Code sich im Wesentlichen selber erklärt, bzw. der TE auch noch etwas zu tun haben soll.

Hautprogramm (User-Interface)

Delphi-Quellcode:

program sv;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  SysUtils,
  SchiffeVersenken in 'SchiffeVersenken.pas';

function ZeichenFuerZelle( Wert : Integer ) : Char;
begin
  case Wert of
    Zelle_Wasser :
      Result := '.';
    Zelle_NebenSchiff :
      Result := '.';
    Zelle_Schiff :
      Result := '.';
    Zelle_SchussWasser :
      Result := 'o';
    Zelle_SchussNebenSchiff :
      Result := 'o';
    Zelle_SchussSchiff :
      Result := 'X';
  end;
end;

procedure ZeigeSpielfeld( Spielfeld : TSpielfeld );
var
  LY : Integer;
  LX : Integer;
begin
  for LY := yMin to yMax do
  begin
    Write( chr( Ord( 'A' ) + LY ), ' ' );
    for LX := xMin to xMax do
      Write( ZeichenFuerZelle( Spielfeld[LX, LY] ) );
    WriteLn;
  end;
end;

function KoordinatenVonEingabe( const Eingabe : string; var x, y : Integer ) : Boolean;
begin
  Result := Length( Eingabe ) >= 2;

  if Result then
    Result := Ord( Eingabe[1] ) >= Ord( 'A' );

  if Result then
    y := Ord( Eingabe[1] ) - Ord( 'A' );

  if Result then
    Result := TryStrToInt( Copy( Eingabe, 2 ), x );

  if Result then
    x := x - 1;
end;

procedure Spiel;
var
  LSpielfeld : TSpielfeld;
  LSchussErgebnis : Integer;
  LSchussKoordinate : string;
  LX, LY : Integer;
begin
  Vorbereiten( LSpielfeld );
  repeat
    ZeigeSpielfeld( LSpielfeld );
    repeat
      repeat
        Write( 'Schuss auf: ' );
        Readln( LSchussKoordinate );
      until KoordinatenVonEingabe( LSchussKoordinate, LX, LY );
      LSchussErgebnis := SchussAuf( LSpielfeld, LX, LY );
      case LSchussErgebnis of
        Schuss_Wasser :
          WriteLn( 'Wasser' );
        Schuss_Treffer :
          WriteLn( 'Treffer' );
        Schuss_SchiffVersenkt :
          WriteLn( 'Treffer und Versenkt' );
        Schuss_FlotteVersenkt :
          WriteLn( 'Treffer, Versenkt und Gewonnen' );
        Schuss_Doppelt :
          WriteLn( 'Auf die Koordinaten ', LSchussKoordinate, ' wurde schon geschossen!' );
        Schuss_Ausserhalb :
          WriteLn( 'Koordinaten ', LSchussKoordinate, ' ungültig!' );
      end;
    until ( LSchussErgebnis <> Schuss_Doppelt ) or ( LSchussErgebnis <> Schuss_Ausserhalb );
  until LSchussErgebnis = Schuss_FlotteVersenkt;
end;

begin
  Randomize;
  try
    Spiel;
  except
    on E : Exception do
      WriteLn( E.ClassName, ': ', E.Message );
  end;
  Readln;

end.

und die Spiellogik

Delphi-Quellcode:

unit SchiffeVersenken;

interface

const
  xMin = 0;
  xMax = 11;
  yMin = 0;
  yMax = 11;

type
  TSpielfeld = array [xMin .. xMax, yMin .. yMax] of Integer;

const
  Zelle_Wasser = 0;
  Zelle_NebenSchiff = 1;
  Zelle_Schiff = 2;
  Schuss = 10;
  Zelle_SchussWasser = Zelle_Wasser + Schuss;
  Zelle_SchussNebenSchiff = Zelle_NebenSchiff + Schuss;
  Zelle_SchussSchiff = Zelle_Schiff + Schuss;

procedure Vorbereiten( var Spielfeld : TSpielfeld );

const
  Schuss_Wasser = 0;
  Schuss_Treffer = 1;
  Schuss_SchiffVersenkt = 2;
  Schuss_FlotteVersenkt = 3;
  Schuss_Doppelt = 4;
  Schuss_Ausserhalb = 5;

function SchussAuf( var Spielfeld : TSpielfeld; x, y : Integer ) : Integer;

implementation

uses
  Math;

const
  Einer = 1;
  Zweier = 2;
  Dreier = 3;
  Vierer = 4;

procedure FuelleBereich( var Spielfeld : TSpielfeld; VonX, BisX, VonY, BisY : Integer; Wert : Integer );
var
  LX : Integer;
  LY : Integer;
begin
  for LY := VonY to BisY do
    for LX := VonX to BisX do
      Spielfeld[LX, LY] := Wert;
end;

const
  Ausrichtung_Horizontal = 0;
  Ausrichtung_Vertikal = 1;

function KannSchiffDorthin( Spielfeld : TSpielfeld; x, y, Ausrichtung, Laenge : Integer ) : Boolean;
var
  LIdx : Integer;
begin
  Result := False;
  case Ausrichtung of
    Ausrichtung_Horizontal :
      begin
        if x + Laenge - 1 <= xMax then
        begin
          Result := True;
          for LIdx := x to x + Laenge - 1 do
          begin
            Result := Result and ( Spielfeld[LIdx, y] = Zelle_Wasser );
          end;
        end;
      end;
    Ausrichtung_Vertikal :
      begin
        if y + Laenge - 1 <= yMax then
        begin
          Result := True;
          for LIdx := y to y + Laenge - 1 do
          begin
            Result := Result and ( Spielfeld[x, LIdx] = Zelle_Wasser );
          end;
        end;
      end;
  end;
end;

procedure PositioniereSchiff( var Spielfeld : TSpielfeld; Laenge : Integer );
var
  LX, LY : Integer;
  LAusrichtung : Integer;
begin
  repeat
    LAusrichtung := Random( 2 );
    LX := Random( xMin + xMax + 1 ) + xMin;
    LY := Random( yMin + yMax + 1 ) + yMin;
  until KannSchiffDorthin( Spielfeld, LX, LY, LAusrichtung, Laenge );

  case LAusrichtung of
    Ausrichtung_Horizontal :
      begin
        FuelleBereich( Spielfeld, Max( xMin, LX - 1 ), Min( xMax, LX + Laenge ), Max( yMin, LY - 1 ), Min( yMax, LY + 1 ), Zelle_NebenSchiff );
        FuelleBereich( Spielfeld, LX, LX + Laenge - 1, LY, LY, Zelle_Schiff );
      end;
    Ausrichtung_Vertikal :
      begin
        FuelleBereich( Spielfeld, Max( xMin, LX - 1 ), Min( xMax, LX + 1 ), Max( xMin, LY - 1 ), Min( yMax, LY + Laenge ), Zelle_NebenSchiff );
        FuelleBereich( Spielfeld, LX, LX, LY, LY + Laenge - 1, Zelle_Schiff );
      end;
  end;

end;

procedure Vorbereiten( var Spielfeld : TSpielfeld );
begin
  FuelleBereich( Spielfeld, xMin, xMax, yMin, yMax, Zelle_Wasser );
  PositioniereSchiff( Spielfeld, Vierer );
  PositioniereSchiff( Spielfeld, Dreier );
  PositioniereSchiff( Spielfeld, Dreier );
  PositioniereSchiff( Spielfeld, Zweier );
  PositioniereSchiff( Spielfeld, Zweier );
  PositioniereSchiff( Spielfeld, Einer );
  PositioniereSchiff( Spielfeld, Einer );
end;

function IstSchiffVersenkt( Spielfeld : TSpielfeld; x, y : Integer ) : Boolean;
var
  LIdx : Integer;
begin
  Result := True;
  LIdx := x;
  while Result and ( LIdx >= xMin ) and ( ( Spielfeld[LIdx, y] = Zelle_Schiff ) or ( Spielfeld[LIdx, y] = Zelle_SchussSchiff ) ) do
  begin
    if Spielfeld[LIdx, y] = Zelle_Schiff then
      Result := False;
    Inc( LIdx, - 1 );
  end;
  LIdx := x;
  while Result and ( LIdx <= xMax ) and ( ( Spielfeld[LIdx, y] = Zelle_Schiff ) or ( Spielfeld[LIdx, y] = Zelle_SchussSchiff ) ) do
  begin
    if Spielfeld[LIdx, y] = Zelle_Schiff then
      Result := False;
    Inc( LIdx, 1 );
  end;
  LIdx := y;
  while Result and ( LIdx >= yMin ) and ( ( Spielfeld[x, LIdx] = Zelle_Schiff ) or ( Spielfeld[x, LIdx] = Zelle_SchussSchiff ) ) do
  begin
    if Spielfeld[x, LIdx] = Zelle_Schiff then
      Result := False;
    Inc( LIdx, - 1 );
  end;
  LIdx := y;
  while Result and ( LIdx <= yMax ) and ( ( Spielfeld[x, LIdx] = Zelle_Schiff ) or ( Spielfeld[x, LIdx] = Zelle_SchussSchiff ) ) do
  begin
    if Spielfeld[x, LIdx] = Zelle_Schiff then
      Result := False;
    Inc( LIdx, 1 );
  end;
end;

function IstFlotteVersenkt( Spielfeld : TSpielfeld ) : Boolean;
var
  LY : Integer;
  LX : Integer;
begin
  Result := True;
  for LY := yMin to yMax do
    for LX := xMin to xMax do
    begin
      if Spielfeld[LX, LY] = Zelle_Schiff then
        Result := False;
    end;
end;

function SchussAuf( var Spielfeld : TSpielfeld; x, y : Integer ) : Integer;
begin
  if InRange( x, xMin, xMax ) and InRange( y, yMin, yMax ) then
  begin
    if Spielfeld[x, y] < Schuss then
    begin
      case Spielfeld[x, y] of
        Zelle_Wasser :
          Result := Schuss_Wasser;
        Zelle_NebenSchiff :
          Result := Schuss_Wasser;
        Zelle_Schiff :
          Result := Schuss_Treffer;
      end;

      Spielfeld[x, y] := Spielfeld[x, y] + Schuss;

      if Result = Schuss_Treffer then
        if IstSchiffVersenkt( Spielfeld, x, y ) then
          if IstFlotteVersenkt( Spielfeld ) then
            Result := Schuss_FlotteVersenkt
          else
            Result := Schuss_SchiffVersenkt;
    end
    else
      Result := Schuss_Doppelt;
  end
  else
    Result := Schuss_Ausserhalb;
end;

end.

[mkinzler]

Wenn du mit gültig: auf dem Brett meint, ja.
Mal dir das doch mal auf Papier auf und beschrifte die Matrix.

[Popov]

@mkinzler

Du hast Recht. Auf der anderen Seite habe ich bereits die Probleme gleich am Anfang zukommen sehen. Ich hab gesehen, dass die Kenntnisse des TE, wenn überhaupt, nur rudimentär sind. Da geht man anders an die Lösung ran, nicht wie ein Profi, auch wenn es eigentlich den "einzig richtigen Weg" gibt. Was dem TE am Anfang für Lösungen für sein Projektplan geliefert wurde, da hätte sogar ich Probleme das umzusetzten. Ich wollte es von anfang an simpel machen. Und wenn es dem Programmierer am abstraktem Denkvermögen fehlt, dann soll er es Try and Error machen. Dann wird eben am Anfang eine Anzeige programmiert und er soll es testen.

[Sir Rufo]

Zitat:

Zitat von mkinzler (Beitrag 1250279)

Wenn du mit gültig: auf dem Brett meint, ja.
Mal dir das doch mal auf Papier auf und beschrifte die Matrix.

Das funktioniert nicht, das habe ich gefühlt in jeder zweiten Antwort von mir gesagt und Reaktion war gleich 0

Zitat:

Zitat von Popov (Beitrag 1250281)

@mkinzler

Du hast Recht. Auf der anderen Seite habe ich bereits die Probleme gleich am Anfang zukommen sehen. Ich hab gesehen, dass die Kenntnisse des TE, wenn überhaupt, nur rudimentär sind. Da geht man anders an die Lösung ran, nicht wie ein Profi, auch wenn es eigentlich den "einzig richtigen Weg" gibt. Was dem TE am Anfang für Lösungen für sein Projektplan geliefert wurde, da hätte sogar ich Probleme das umzusetzten. Ich wollte es von anfang an simpel machen. Und wenn es dem Programmierer am abstraktem Denkvermögen fehlt, dann soll er es Try and Error machen. Dann wird eben am Anfang eine Anzeige programmiert und er soll es testen.

Absoluter Unsinn ... gerade wenn Projektteilnehmer nicht programmieren können, bleibt man so lange wie möglich weg von der Implementierung sondern schreibt das in verständlichen Worten auf.

Ein jeder, der dir einen Zusammenhang nicht erklären kann ohne sich hinter Fachtermini oder Implementationsgeschwafel zu verstecken, hat im Grunde keine Ahnung wie es funktioniert. Er weiß lediglich wo er mit dem Hammer hinschlagen muss, aber er weiß nicht warum und wieso.

Einfach mal in den nächsten Gesprächen darauf achten ... es geht immer mit einfachen Worten zu erklären ... es dauert länger, evtl. muss man weiter ausholen ... aber es geht.

[DeddyH]

@Sir Rufo: :thumb: made my day

[Popov]

@Sir Rufo

Den TE wird es freuen. Er wird vermutlich nichts davon verstehen, aber du hast dich durchgesetzt, den Code geliefert, dem TE einen einfachen Weg aufgezeigt. Vielleicht wird er das auch nehmen. Hast du das nötig gehabt? Der Lehrer wird erkennen, dass es nicht sein Code ist, somit ist alles was du hier geliefert hast absolut wertlos. Ich wollte dem TE langsam, aber selbst das Programm programmieren lassen. Jetzt ist es mit zu dumm es weiter zu machen. Der TE gehört dir.

[Popov]

Zitat:

Zitat von Sir Rufo (Beitrag 1250283)

Absoluter Unsinn ...

Sir Rufo, ich bin seit 15 Jahren u. a. als Dozent tätig, bzw. führe Schulungen durch, als Ausbilder bin ich seit 30 Jahren tätig. Ich hab sehr oft mit blutigen Anfängern zu tun. Kannst du das auch vorweisen? Du hast sehr gute Kenntnisse als Programmierer, aber ich sage dir was - bei eurer Hilfe am Anfang musste ich nur Kopf schütteln. Didaktisch eine Katastrophe. Wenn ich von etwas eine Ahnung habe, dann wie man einen Anfänger an das Ziel bringe, denn das mache ich seit Jahren. Merke dir, programmieren können bedeutet nicht zu wissen wie man einem anderen das beibringen kann.

Und zu deinem Code, der ist eine Katastrophe. Programmtechnisch sehr gut, aber für einen Anfänger nicht zu gebrauchen. Den Code soll der TE verstehen? Bravo.

[leodinho]

Zitat:

Zitat von Sir Rufo (Beitrag 1250278)

So, ich kann mir das Elend nicht mehr mit anschauen und hier ein fertiges Schiffe Versenken in einer Konsolen-Version und ohne Highscore.

Wie man sieht bleibt vom eigentlichen Spiel nicht viel mehr als Vorbereiten und SchussAuf.
Logisch, denn die Erfassung der Schusskoordinaten und Ausgabe des Spielfeldes gehört zum User-Interface und nicht zum Spiel, denn das Spiel funktioniert auch ohne User-Interface.

Es ist bewusst rudimentär gehalten ohne viel BlinkBlink um den Blick nicht vom Wesentlichen abzulenken.
Ich habe mir erlaubt keine Kommentare zu setzen, da der Code sich im Wesentlichen selber erklärt, bzw. der TE auch noch etwas zu tun haben soll.

Hautprogramm (User-Interface)

Delphi-Quellcode:

program sv;

{$APPTYPE CONSOLE}
{$R *.res}

uses
  SysUtils,
  SchiffeVersenken in 'SchiffeVersenken.pas';

function ZeichenFuerZelle( Wert : Integer ) : Char;
begin
  case Wert of
    Zelle_Wasser :
      Result := '.';
    Zelle_NebenSchiff :
      Result := '.';
    Zelle_Schiff :
      Result := '.';
    Zelle_SchussWasser :
      Result := 'o';
    Zelle_SchussNebenSchiff :
      Result := 'o';
    Zelle_SchussSchiff :
      Result := 'X';
  end;
end;

procedure ZeigeSpielfeld( Spielfeld : TSpielfeld );
var
  LY : Integer;
  LX : Integer;
begin
  for LY := yMin to yMax do
  begin
    Write( chr( Ord( 'A' ) + LY ), ' ' );
    for LX := xMin to xMax do
      Write( ZeichenFuerZelle( Spielfeld[LX, LY] ) );
    WriteLn;
  end;
end;

function KoordinatenVonEingabe( const Eingabe : string; var x, y : Integer ) : Boolean;
begin
  Result := Length( Eingabe ) >= 2;

  if Result then
    Result := Ord( Eingabe[1] ) >= Ord( 'A' );

  if Result then
    y := Ord( Eingabe[1] ) - Ord( 'A' );

  if Result then
    Result := TryStrToInt( Copy( Eingabe, 2 ), x );

  if Result then
    x := x - 1;
end;

procedure Spiel;
var
  LSpielfeld : TSpielfeld;
  LSchussErgebnis : Integer;
  LSchussKoordinate : string;
  LX, LY : Integer;
begin
  Vorbereiten( LSpielfeld );
  repeat
    ZeigeSpielfeld( LSpielfeld );
    repeat
      repeat
        Write( 'Schuss auf: ' );
        Readln( LSchussKoordinate );
      until KoordinatenVonEingabe( LSchussKoordinate, LX, LY );
      LSchussErgebnis := SchussAuf( LSpielfeld, LX, LY );
      case LSchussErgebnis of
        Schuss_Wasser :
          WriteLn( 'Wasser' );
        Schuss_Treffer :
          WriteLn( 'Treffer' );
        Schuss_SchiffVersenkt :
          WriteLn( 'Treffer und Versenkt' );
        Schuss_FlotteVersenkt :
          WriteLn( 'Treffer, Versenkt und Gewonnen' );
        Schuss_Doppelt :
          WriteLn( 'Auf die Koordinaten ', LSchussKoordinate, ' wurde schon geschossen!' );
        Schuss_Ausserhalb :
          WriteLn( 'Koordinaten ', LSchussKoordinate, ' ungültig!' );
      end;
    until ( LSchussErgebnis <> Schuss_Doppelt ) or ( LSchussErgebnis <> Schuss_Ausserhalb );
  until LSchussErgebnis = Schuss_FlotteVersenkt;
end;

begin
  Randomize;
  try
    Spiel;
  except
    on E : Exception do
      WriteLn( E.ClassName, ': ', E.Message );
  end;
  Readln;

end.

und die Spiellogik

Delphi-Quellcode:

unit SchiffeVersenken;

interface

const
  xMin = 0;
  xMax = 11;
  yMin = 0;
  yMax = 11;

type
  TSpielfeld = array [xMin .. xMax, yMin .. yMax] of Integer;

const
  Zelle_Wasser = 0;
  Zelle_NebenSchiff = 1;
  Zelle_Schiff = 2;
  Schuss = 10;
  Zelle_SchussWasser = Zelle_Wasser + Schuss;
  Zelle_SchussNebenSchiff = Zelle_NebenSchiff + Schuss;
  Zelle_SchussSchiff = Zelle_Schiff + Schuss;

procedure Vorbereiten( var Spielfeld : TSpielfeld );

const
  Schuss_Wasser = 0;
  Schuss_Treffer = 1;
  Schuss_SchiffVersenkt = 2;
  Schuss_FlotteVersenkt = 3;
  Schuss_Doppelt = 4;
  Schuss_Ausserhalb = 5;

function SchussAuf( var Spielfeld : TSpielfeld; x, y : Integer ) : Integer;

implementation

uses
  Math;

const
  Einer = 1;
  Zweier = 2;
  Dreier = 3;
  Vierer = 4;

procedure FuelleBereich( var Spielfeld : TSpielfeld; VonX, BisX, VonY, BisY : Integer; Wert : Integer );
var
  LX : Integer;
  LY : Integer;
begin
  for LY := VonY to BisY do
    for LX := VonX to BisX do
      Spielfeld[LX, LY] := Wert;
end;

const
  Ausrichtung_Horizontal = 0;
  Ausrichtung_Vertikal = 1;

function KannSchiffDorthin( Spielfeld : TSpielfeld; x, y, Ausrichtung, Laenge : Integer ) : Boolean;
var
  LIdx : Integer;
begin
  Result := False;
  case Ausrichtung of
    Ausrichtung_Horizontal :
      begin
        if x + Laenge - 1 <= xMax then
        begin
          Result := True;
          for LIdx := x to x + Laenge - 1 do
          begin
            Result := Result and ( Spielfeld[LIdx, y] = Zelle_Wasser );
          end;
        end;
      end;
    Ausrichtung_Vertikal :
      begin
        if y + Laenge - 1 <= yMax then
        begin
          Result := True;
          for LIdx := y to y + Laenge - 1 do
          begin
            Result := Result and ( Spielfeld[x, LIdx] = Zelle_Wasser );
          end;
        end;
      end;
  end;
end;

procedure PositioniereSchiff( var Spielfeld : TSpielfeld; Laenge : Integer );
var
  LX, LY : Integer;
  LAusrichtung : Integer;
begin
  repeat
    LAusrichtung := Random( 2 );
    LX := Random( xMin + xMax + 1 ) + xMin;
    LY := Random( yMin + yMax + 1 ) + yMin;
  until KannSchiffDorthin( Spielfeld, LX, LY, LAusrichtung, Laenge );

  case LAusrichtung of
    Ausrichtung_Horizontal :
      begin
        FuelleBereich( Spielfeld, Max( xMin, LX - 1 ), Min( xMax, LX + Laenge ), Max( yMin, LY - 1 ), Min( yMax, LY + 1 ), Zelle_NebenSchiff );
        FuelleBereich( Spielfeld, LX, LX + Laenge - 1, LY, LY, Zelle_Schiff );
      end;
    Ausrichtung_Vertikal :
      begin
        FuelleBereich( Spielfeld, Max( xMin, LX - 1 ), Min( xMax, LX + 1 ), Max( xMin, LY - 1 ), Min( yMax, LY + Laenge ), Zelle_NebenSchiff );
        FuelleBereich( Spielfeld, LX, LX, LY, LY + Laenge - 1, Zelle_Schiff );
      end;
  end;

end;

procedure Vorbereiten( var Spielfeld : TSpielfeld );
begin
  FuelleBereich( Spielfeld, xMin, xMax, yMin, yMax, Zelle_Wasser );
  PositioniereSchiff( Spielfeld, Vierer );
  PositioniereSchiff( Spielfeld, Dreier );
  PositioniereSchiff( Spielfeld, Dreier );
  PositioniereSchiff( Spielfeld, Zweier );
  PositioniereSchiff( Spielfeld, Zweier );
  PositioniereSchiff( Spielfeld, Einer );
  PositioniereSchiff( Spielfeld, Einer );
end;

function IstSchiffVersenkt( Spielfeld : TSpielfeld; x, y : Integer ) : Boolean;
var
  LIdx : Integer;
begin
  Result := True;
  LIdx := x;
  while Result and ( LIdx >= xMin ) and ( ( Spielfeld[LIdx, y] = Zelle_Schiff ) or ( Spielfeld[LIdx, y] = Zelle_SchussSchiff ) ) do
  begin
    if Spielfeld[LIdx, y] = Zelle_Schiff then
      Result := False;
    Inc( LIdx, - 1 );
  end;
  LIdx := x;
  while Result and ( LIdx <= xMax ) and ( ( Spielfeld[LIdx, y] = Zelle_Schiff ) or ( Spielfeld[LIdx, y] = Zelle_SchussSchiff ) ) do
  begin
    if Spielfeld[LIdx, y] = Zelle_Schiff then
      Result := False;
    Inc( LIdx, 1 );
  end;
  LIdx := y;
  while Result and ( LIdx >= yMin ) and ( ( Spielfeld[x, LIdx] = Zelle_Schiff ) or ( Spielfeld[x, LIdx] = Zelle_SchussSchiff ) ) do
  begin
    if Spielfeld[x, LIdx] = Zelle_Schiff then
      Result := False;
    Inc( LIdx, - 1 );
  end;
  LIdx := y;
  while Result and ( LIdx <= yMax ) and ( ( Spielfeld[x, LIdx] = Zelle_Schiff ) or ( Spielfeld[x, LIdx] = Zelle_SchussSchiff ) ) do
  begin
    if Spielfeld[x, LIdx] = Zelle_Schiff then
      Result := False;
    Inc( LIdx, 1 );
  end;
end;

function IstFlotteVersenkt( Spielfeld : TSpielfeld ) : Boolean;
var
  LY : Integer;
  LX : Integer;
begin
  Result := True;
  for LY := yMin to yMax do
    for LX := xMin to xMax do
    begin
      if Spielfeld[LX, LY] = Zelle_Schiff then
        Result := False;
    end;
end;

function SchussAuf( var Spielfeld : TSpielfeld; x, y : Integer ) : Integer;
begin
  if InRange( x, xMin, xMax ) and InRange( y, yMin, yMax ) then
  begin
    if Spielfeld[x, y] < Schuss then
    begin
      case Spielfeld[x, y] of
        Zelle_Wasser :
          Result := Schuss_Wasser;
        Zelle_NebenSchiff :
          Result := Schuss_Wasser;
        Zelle_Schiff :
          Result := Schuss_Treffer;
      end;

      Spielfeld[x, y] := Spielfeld[x, y] + Schuss;

      if Result = Schuss_Treffer then
        if IstSchiffVersenkt( Spielfeld, x, y ) then
          if IstFlotteVersenkt( Spielfeld ) then
            Result := Schuss_FlotteVersenkt
          else
            Result := Schuss_SchiffVersenkt;
    end
    else
      Result := Schuss_Doppelt;
  end
  else
    Result := Schuss_Ausserhalb;
end;

end.

Du hättest dir nicht die mühe machen sollen /:
Ich werde meins so wie es jetzt ist abgeben, da es das ist was ich zustande gebracht habe.. egal was dabei rauskommt..

Trotzdem nochmal danke für eure hilfe aber programmieren ist nicht mein ding /:

[Sir Rufo]

Zitat:

Zitat von Popov (Beitrag 1250290)

Zitat:

Zitat von Sir Rufo (Beitrag 1250283)

Absoluter Unsinn ...

Sir Rufo, ich bin seit 15 Jahren u. a. als Dozent tätig, bzw. führe Schulungen durch, als Ausbilder bin ich seit 30 Jahren tätig. Ich hab sehr oft mit blutigen Anfängern zu tun. Kannst du das auch vorweisen? Du hast sehr gute Kenntnisse als Programmierer, aber ich sage dir was - bei eurer Hilfe am Anfang musste ich nur Kopf schütteln. Didaktisch eine Katastrophe. Wenn ich von etwas eine Ahnung habe, dann wie man einen Anfänger an das Ziel bringe, denn das mache ich seit Jahren. Merke dir, programmieren können bedeutet nicht zu wissen wie man einem anderen das beibringen kann.

Und zu deinem Code, der ist eine Katastrophe. Programmtechnisch sehr gut, aber für einen Anfänger nicht zu gebrauchen. Den Code soll der TE verstehen? Bravo.

Na denn ...