Schiffe versenken programmieren

[TForm1]

Also ich würde, wie Sir Rufo schon gesagt hat erst einmal Zettel und Stift zur Hand nehmen und grob die Benutzeroberfläche zeichnen und dir erst eimal darüber Klar werden, wie dein Programm aussehen soll, was passieren soll wenn man auf den und den Button bzw. Feld klickt. D.h. ganz logisch das gesamte Programm erst einmal konzipieren und noch keinen Gedanken daran verschwenden, wie es dann umgesetzt werden soll.

Wenn du das alles gemacht hast kannst Du dir die grobe Strukturierung des Codes überlegen, d.h. noch nicht in Einzelheiten verfallen, sondern dir z.B. überlegen wie viele Units du brauchst(wenn du z.B. mehrere Fenster verwendest), wie diese miteinander verbunden werden sollen und welche Prozeduren du benötigst und was diese wiederum machen sollen.
Und dann müsstest Du auch schon das haben, was dein Lehrer von dir bis Dienstag verlangt hat.

Danach kannst Du den Code ganz in Ruhe umsetzen.

[leodinho]

Wofür bräuchte ich mehrere Units?
Und ich muss aber meine Sachen die ich aufgemalt habe irgendwie so verabreiten dass ich das Dienstag abgeben kann.. Ich bin echt überfordet mit dem Versuch wenigstens etwas zu haben :?

[TForm1]

Mehrere Units bräuchtest du nur dann, wenn Du mehrere Fenster haben willst. Du brauchst ja so oder so 2 Spielfelder für die beiden Spieler. Dann solltest Du z.B. schon mal wissen, ob Du beide Felder in einem Fenster hast (Was allerdings unsinnig wäre da sich dann ja die Spieler gegenseitig aufs Spielfeld gucken könnten, aber das ist programmiertechnisch egal) oder ob Du die Felder nacheinander ein- und ausblenden lassen willst sodass immer das Feld des Spielers, der gerade am Zug ist, aktiv ist. Das sind so grundlegende Sachen, da würde ich mich erst mal entscheiden. Wie Du das dann realisierst, kannst du dann im 2. Schritt überlegen.

Ich weiß ja nicht, in welcher Form dein Lehrer die Projektplanung verlangt, aber grundsätzlich würde es ausreichen, wenn Du im 2.Schritt die Struktur des Quellcodes(z.B. welche Prozeduren benötigt werden) als Diagramm (mit Pfeilen usw.) aufzeichnest. Das kannst Du aber erst machen, wenn Du mit Schritt1 fertig bist.

Deswegen würde ich erst mal zur Ruhe kommen und noch mal ganz von Vorne logisch dein Programm aufbauen.

[leodinho]

Ok ich werde mich morgen nochmal hier melden..
Müsste das ja in paar Stunden morgen hinkriegen /:

Aber nochmal zu den Feldern..
Ich hab mir gedacht, dass ich nur ein Feld mache , wo Schiffe zufällig aufgeteilt werden..
Desweiteren hat dann ein Spieler Zeit , diese Schiffe zu suchen und ''zerstören''.
Das wichtige dabei ist dann, wie viel Züge er dafür braucht..
Diese Züge werden dann am Ende zusammengerechnet und gelangen in den Highscore.
So wäre meine Idee gewesen..
Da ich glaube, dass es mit einem 2 Feld und einem Computer noch schwieriger ist.

[TForm1]

Achso, dann habe ich das falsch verstanden. Ich habe gedacht, Du wolltest ein Spiel für 2 Spieler machen, die sich dann abwechselnd gegenseitig "beschießen".
So ist das natürlich deutlich einfacher.

[Popov]

Zitat:

Zitat von Sir Rufo (Beitrag 1243311)

Mal ne Frage (auch an Popov):

Habt ihr das Spiel "Schiffe versenken" verstanden?

Jep.

Zitat:

Meines Wissens nach gibt es für die Platzierung folgende Regeln:

Steht in etwa auch so in Wikipedia.

Zitat:

Mit diesen Regeln ist es unerheblich zu wissen, welches Schiff es ist, sondern kann durch das Auswerten der Nachbarfelder (horizontal, vertikal) herausfinden ob das Schiff versenkt ist oder nicht.

Jajn. Auf dem Papier ist das sehr einfach. Deshalb sind das auch die Regeln für die Papiervariante, denn bei so einem Aufbau:

Code:

0000000000
XXXXX00000
X000000000
X000000000
0000000000
0000000000

weiß man auf dem Papier nicht ob das ein 5'er und dein 2'er Schiff ist, oder ein 4'er und ein 3'er.

Deshalb auf dem Papier:

Code:

0000000000
XXXXX00000
0000000000
X000000000
X000000000
0000000000

Nun ist die Sache klar. Auf dem Papier.

Nun eine Computerversion:

Code:

0000000000
2111100000
2000000000
2000000000
0000000000
0000000000

Kein Problem, hier kann man erkennen welches Feld für welches Schiff gilt.

Aber bleiben wir mal bei den Regeln für Papierversion. Hier zwei Varianten nebeneinander:

Code:

0000000000 0000000000
XXXXX00000 1111100000
0000000000 0000000000
X000000000 2000000000
X000000000 2000000000
0000000000 0000000000

Welche Version ist leichter auszuwerten? Bei der linken Version mußt man erst mit einer Logik das Schiff lokalisieren, dann erkennen um welches es sich handelt, dh. dazu muss man nicht nur Felder zählen, sondern erkennen wo das Schiff einen Anfang und wo Ende hat. Dann zählt man die Felder dazwischen. Sorry, das ist aber mit Verlaub die komplizierteste aller Arten wie man das Problem angehen muss, denn man muss hier eine Logik programmieren. Bei der zweiten Variante weiß ich, dass Schiff 1 fünf Felder lang ist. Jetzt brauche ich nur noch alle Felder prüfen. Finde ich keine 1 mehr auf dem Feld, weiß ich, dann Schiff 1 versunken ist.

Zitat:

@Popov

Eine Textaufgabe löst man, indem man den Sinn versteht, in einzelnen logischen Teile zerlegt und sich den passenden Rechenweg überlegt.
Dann fängt man an zu rechnen.

Ja. Aber wenn nach zwei Tagen immer noch die Bitte zu hören ist, dass die Idee für den Anfang fehlt, dann sollte man vielleicht ein Ziel vorschlagen. Das ist wie mit einer Reise in den Urlaub wo man am Flughafen steht und nicht weiß wo man eigentlich hin will.

Was ich mit meinem abgewandeltem Tic Tac Toe geboten habe ist ein Ziel auf das man hinarbeiten kann. Man fängt auch kein Haus zu bauen ohne zu wissen wie es aussagen will. Das Ziel ist vorgegeben. So abwegig ist also meine Hilfe mit dem Raster nicht.

Auf der andere Seite ist die Diskussion wohl aber eher akademisch, denn ich hab das Gefühl, dass der TE sich auf StringGrid eingeschossen hat.

[Sir Rufo]

Das mit dem Haus ist ein gutes Beispiel.

Bevor auch nur ein Stein bewegt wird (Umsetzung) wird eine Zeichnung erstellt (Plan).
Bei Software sind die Steine Codezeilen und die Zeichnung eben der Plan.

Die Aufgabe, die der TE zu erfüllen hat besteht aus einem Plan (Deadline Dienstag) und dem fertigen Programm (Deadline in 2 Monaten).

Daraus folgere ich: Code hilft ihm im Moment nicht weiter, das Zwischenziel am Dienstag (Plan) zu erreichen.

Die Ermittlung ob ein Schiff versenkt wurde, kann mit meiner Methode per Rekursion ermittelt werden (beliebt bei Info-Lehreren)
Etwas Ähnliches wird benötigt um die Positionierung des Schiffs zu überprüfen.

Des Weiteren würde ich die Schiffe über eine Lookup-Tabelle identifizieren. Dadurch kann das Spielfeld bleiben, wie es ist (und die Schusslogik) auch wenn die Anzahl und Größe der Schiffe variiert.

BTW: In einen Plan gehören auch diese unterschiedlichen Lösungsansätze (auch deiner) mit rein und man vergleicht die Vor- und Nachteile. Dann entscheidet man sich für einen Weg und der wird dann umgesetzt.

[Popov]

Wobei ich mir schon vorhin überlegt habe wozu überhaupt ein Array nötig ist. Man kann genauso gut 10 Arrays für 10 Schiffe erstellen, die Größe entspricht der Länge der Schiffe, Typ TPoint. Die Koordinate wo sich die Schiffe befinden (bzw. jedes Teil des Schiffes) ist nicht in dem Feld vermerkt, sondern in TPoints des Schiff-Arrays, z. B.

Delphi-Quellcode:

var Kreuzer1: array[1..5] of TPoint;

. Schießt der Gegner, prüft man nicht das Feld, sondern geht alle Schiffe durch und prüft auf Treffer.

So würde ich das angehen, weil am einfachsten. Aber das ist nicht die klassische Methode und ich weiß nicht was der Lehrer sehen will.

[Mavarik]

Zitat:

Zitat von Popov (Beitrag 1243351)

Wobei ich mir schon vorhin überlegt habe wozu überhaupt ein Array nötig ist. Man kann genauso gut 10 Arrays für 10 Schiffe erstellen, die Größe entspricht der Länge der Schiffe, Typ TPoint. Die Koordinate wo sich die Schiffe befinden (bzw. jedes Teil des Schiffes) ist nicht in dem Feld vermerkt, sondern in TPoints des Schiff-Arrays, z. B.

Delphi-Quellcode:

var Kreuzer1: array[1..5] of TPoint;

. Schießt der Gegner, prüft man nicht das Feld, sondern geht alle Schiffe durch und prüft auf Treffer.

So würde ich das angehen, weil am einfachsten. Aber das ist nicht die klassische Methode und ich weiß nicht was der Lehrer sehen will.

Einfacher als

Delphi-Quellcode:

if Feld[X,Y] <> Wasser then 
  Treffer;

Naja :wall:

[Mavarik]

Zitat:

Zitat von leodinho (Beitrag 1243280)

@ Mavarik
Kannst du gerne machen jedoch hilft mir das auch nicht weiter, wenn ich ein fertiges Programm oderso hätte..

Danke für die Erlaubnis! Die Zielgruppe waren auch eher die Profis hier im Forum. Gedacht als kleine Abwechslung für zwischendurch.

[Popov]

Zitat:

Zitat von Mavarik (Beitrag 1243395)

Einfacher als

Delphi-Quellcode:

if Feld[X,Y] <> Wasser then 
  Treffer;

Naja :wall:

Ja.

Hast du dir schon Gedanken zum Spiel gemacht? Ich gestern schon. Mit der oberen Abfrage ist es nicht getan. Wenn du das alles mit dem oberen Code schaffst, dann hast du meinen Respekt. Mit der oberen Abfrage erkennst du auf einen Treffer, aber nicht ob ein Schiff versenkt wurde. Zwar könntest du nach jeder Abfrage zusätzlich das ganze Feld prüfen ob alles getroffen wurde, du wüsstest dann zumindest ob alles getroffen wurde was zu treffen war und du gewonnen hast, aber du könntest keine Zwischenergebnisse liefern, ob z. B. ein Schiff versenkt wurde. In dem Fall müsstest du mit einer logischen Routine Schiffe auf dem Feld suchen und als solche erkennen. Und auch wenn die oben genannten Regeln eher für Papiervarianten gelten, denn in Computerversionen stoßen die Schiffe durchaus zusammen, aber bleiben wir mal bei Papierregeln, so ist es nicht verboten, dass Schiffe nebeneinander liegen. Womit die Lokalisierung eines Schiffes nicht mehr so einfach über freie Felder neben dem Schiff wären.

Also, weil du den :wall: -Smiley ins Spiel brachtest, würde ich gerne deine Lösung sehen.

[DeddyH]

Man könnte es mit Mengenlehre versuchen. Dazu müssen die Felder zwar in Byte umgerechnet werden, aber das ist ja keine allzu große Hürde. Dann bekommt jedes Schiff eine Menge und die Schüsse auch. Ein Schiff ist dann versenkt, wenn seine Feldmenge komplett in der Schussmenge enthalten ist. Einfacher geht es IMHO kaum.

[leodinho]

Also schonmal Danke, dass ich euch für mein Problem so viel Zeit nehmt :wink:

Zitat:

Zitat von Sir Rufo (Beitrag 1243350)

Das mit dem Haus ist ein gutes Beispiel.


Die Aufgabe, die der TE zu erfüllen hat besteht aus einem Plan (Deadline Dienstag) und dem fertigen Programm (Deadline in 2 Monaten).

Daraus folgere ich: Code hilft ihm im Moment nicht weiter, das Zwischenziel am Dienstag (Plan) zu erreichen.

Die Ermittlung ob ein Schiff versenkt wurde, kann mit meiner Methode per Rekursion ermittelt werden (beliebt bei Info-Lehreren)
Etwas Ähnliches wird benötigt um die Positionierung des Schiffs zu überprüfen.

Des Weiteren würde ich die Schiffe über eine Lookup-Tabelle identifizieren. Dadurch kann das Spielfeld bleiben, wie es ist (und die Schusslogik) auch wenn die Anzahl und Größe der Schiffe variiert.

BTW: In einen Plan gehören auch diese unterschiedlichen Lösungsansätze (auch deiner) mit rein und man vergleicht die Vor- und Nachteile. Dann entscheidet man sich für einen Weg und der wird dann umgesetzt.

Genau solche Vorschläge habe ich benötigt :thumb:

Mein Plan war jetzt:
1. Generieren des Spielfeldes durch eine Imgakomponente ( evtl. StringGrid )
2. Spiel Starten -> Schiffe zufällig auf dem Feld platzieren ( Wie? )
3. Klick auf das Feld (Zähler +1):

3.1 Treffer? -> Ja -> Dann Überprüfung ob Schiff versenkt? -> Ja -> Meldung ''Schiff versenkt'' ( Nein? -> Dann naechster Klick

3.2 Treffer? -> Nein -> Dann naechster Klick

4. Solange Wiederholen bis alle Schiffe getroffen wurden -> 1.-3. weiderholen
5. Alle Schiffe getroffen? -> Ja -> Meldung: ''Sie haben gewonnen - ... Versuche''
6. Hervorhebung des Highscores -> Name eintragen -> Im Highscore speichern

Waere das so für das komplette Programm eine grober Plan?
Hoffe ihr könnt mir Folgen (:

Danke im Vorraus. :thumb:

[Popov]

Das Platzieren der Schiffe ist einer der beiden Hauptaufgaben. Die zweite ist mit einer Logik die Schiffe des Spielers durch den Computer zu finden. Wobei das ist noch für die einfachere der beiden Hauptaufgaben halten, denn wenn ich mir einige Battleship Computerspiele angucke, wird nur nach einem Raster gesucht. Wird was gefunden, wird die Nachbarschaft geprüft.

Die komplizierter der beiden Hauptaufgaben ist eher das Platzieren der Schiffe. Was für den Menschen kein Problem ist, muss erst mit Logik im Programm umgesetzt werden. Die Überschneidung der Schiffe prüfen ist noch das kleinere Problem. Das kann man noch relativ einfach prüfen. Etwas schwieriger ist die Prüfung auf das aneinander Stoßen, denn aneinander stoßen bedeutet nicht, dass die Schiffe sich nicht berühren dürfen. Parallel aneinander liegen ist nach den Regeln nicht verboten.

[leodinho]

@ Popov

Wie ich schon gesagt habe.. Ich mache nur ein Feld, d.h. ich hab kein Computer der Spielzüge machen muss..
Das Ziel ist es mit so wenig Zügen wie möglich zu gewinnen.

Mein Plan war jetzt (Überarbeitet):
1. Generieren des Spielfeldes durch eine Imgakomponente ( evtl. StringGrid )
2. Spiel Starten -> Schiffe zufällig auf dem Feld platzieren ( Wie? )
3. Klick auf das Feld (Zähler +1) ( if ... then ; else ... )

3.1 Treffer? -> Ja -> Dann Überprüfung ob Schiff versenkt? -> Ja -> Meldung ''Schiff versenkt'' ( Nein? -> Dann naechster Klick

3.2 Treffer? -> Nein -> Dann naechster Klick

4. Solange Wiederholen bis alle Schiffe getroffen wurden -> 1.-3. weiderholen
5. Alle Schiffe getroffen? -> Ja -> Meldung: ''Sie haben gewonnen - ... Versuche''
6. Hervorhebung des Highscores -> Name eintragen -> Im Highscore speichern

[DeddyH]

Vergiss das Grid erst einmal, das ist ja nur die Darstellung. Du solltest zunächst das Gesamtproblem in kleinere Teilprobleme und diese wiederum in noch kleinere Teilprobleme zerlegen, bis eine weitere Zerlegung nicht mehr sinnvoll erscheint. Diese "Kleinstprobleme" werden dann einzeln in Funktionen oder Prozeduren gelöst. Nehmen wir doch die Platzierung als Beispiel:
- Zufällige Position ermitteln
- Position zulässig?
-> alle Regelbedingungen erfüllt?
Ja -> nächstes Schiff
Nein -> zurück zum Anfang

Man könnte also eine Funktion ZulaessigePosition mit einem Boolean-Rückgabewert schreiben, die nacheinander die Regelbedingungen (wieder einzelne Boolean-Funktionen) abprüft. Nach diesem Schema baut man dann nach und nach die gesamte Anwendung auf.

[leodinho]

ok ich werde jetzt mit Hilfreichen Punkten den Plan erweitern (:

Mein Plan war jetzt (Überarbeitet):
1. Generieren des Spielfeldes durch eine Imgakomponente ( evtl. StringGrid )
2. Spiel Starten -> Schiffe zufällig auf dem Feld platzieren ( evtl mit Boolean ''True o. False'' )

2.1. Zufällige Position ermitteln

2.2. Position zulässig? -> Alle Regelbedingungen erfüllt?

2.3. Ja -> nächstes Schiff // Nein -> zurück zum Anfang

3. Klick auf das Feld (Zähler +1) ( if ... then ; else ... )

3.1 Treffer? -> Ja -> Dann Überprüfung ob Schiff versenkt? -> Ja -> Meldung ''Schiff versenkt'' // Nein? -> Dann naechster Klick

3.2 Treffer? -> Nein -> Dann naechster Klick

4. Solange Wiederholen bis alle Schiffe getroffen wurden -> 1.-3. weiderholen
5. Alle Schiffe getroffen? -> Ja -> Meldung: ''Sie haben gewonnen - ... Versuche''
6. Hervorhebung des Highscores -> Name eintragen -> Im Highscore speichern

Über weitere Vorschläge und Hinweise wäre ich Dankbar (:
Könnte ich 3. mit ''if'' machen?

[DeddyH]

Es gibt bei 3. ja nur 2 Möglichkeiten: Treffer oder kein Treffer, da bietet sich ein If ja geradezu an ;)

[Sir Rufo]

Die Platzierung der Schiffe kann so erfolgen:

1. zufällige Orientierung festlegen (horizontal/vertikal)
2. zufällige Start-Koordinaten festlegen

Für die Start-Koordinaten gibt es aber je nach Orientierung und Schiffsgröße Einschränkungen, die man schon im Vorfeld berücksichtigen kann:

• 4er Schiff horizontal
  Anhang 40519
  
  Code:

  x => 1..[Spielfeldbreite]-[Schiffsgröße]+1
  y => 1..[Spielfeldhöhe]

• 4er Schiff vertikal
  Anhang 40520
  
  Code:

  x => 1..[Spielfeldbreite]
  y => 1..[Spielfeldhöhe]-[Schiffsgröße]+1

Befinden sich jetzt schon Schiffe auf dem Spielfeld, so verringern sich auch die möglichen Felder für die Start-Koordinaten

• 3er Schiff horizontal
  Anhang 40521

Hier hätte man jetzt folgende Möglichkeiten

• Ermitteln aller gültigen Start-Koordinaten und aus dieser Menge zufällig eine auswählen
• Ermitteln einer zufälligen Start-Koordinate wie gehabt und dann mit dem Spielfeld vergleichen, ob das Feld nicht belegt ist.
  Das wird solange wiederholt, bis man das Schiff platzieren kann.

Wenn man das so betrachtet, dann könnte es Sinn machen, einen weiteren Feld-Status einzuführen

Delphi-Quellcode:

NearShip

und beim Platzieren des Schiffs diesen Status in alle Nachbarfelder zu schreiben. Dann wird auch die Prüfung wesentlich unkomplizierter.

Im Spiel selber wird der Status

Delphi-Quellcode:

NearShip

dann genauso behandelt wie

Delphi-Quellcode:

Water

.

Hier mal der interne Zustand des Spielfeldes nach 7 Schüssen
Anhang 40522
Legende
Anhang 40523

[leodinho]

Vielen Dank Ruso, jedoch möchte ich erstmal mein kompletten Plan fertigstellen und dass geht doch schon wieder in die Richtung Codierung? ^^

[Sir Rufo]

Zitat:

Zitat von leodinho (Beitrag 1243456)

Vielen Dank Ruso, jedoch möchte ich erstmal mein kompletten Plan fertigstellen und dass geht doch schon wieder in die Richtung Codierung? ^^

Hast du da irgendwo Code gesehen? Ich nicht ... das gehört in den Projektplan

[Sir Rufo]

Für die Spieler-Anzeige werden

Delphi-Quellcode:

Water

,

Delphi-Quellcode:

NearShip

und

Delphi-Quellcode:

Ship

behandelt wie

Delphi-Quellcode:

Water

und man bekommt bei diesem Stand
Anhang 40526 das heraus Anhang 40524
Legende
Anhang 40525

[leodinho]

ok ok ^^
Ich werde deine Idee in meine Projektplanung die ich morgen mache einbeziehen ja? (:
Das wurde ja mithilfe des StringGrids gemacht oder?
Dann werde ich die Bilder als Anschauung für unsere lehrerin benutzen. (:

[Sir Rufo]

Zitat:

Zitat von leodinho (Beitrag 1243464)

ok ok ^^
Ich werde deine Idee in meine Projektplanung die ich morgen mache einbeziehen ja? (:
Das wurde ja mithilfe des StringGrids gemacht oder?
Dann werde ich die Bilder als Anschauung für unsere lehrerin benutzen. (:

Die Bilder habe ich mit Pages (Textverarbeitung) gemacht.
Da ist nicht ein Gramm Delphi (oder sonstige Programmiersprache) drin

Das meinte ich die ganze Zeit mit Blatt Papier und malen ... :roll:

[Popov]

Zitat:

Zitat von leodinho (Beitrag 1243449)

Mein Plan war jetzt (Überarbeitet):
1. Generieren des Spielfeldes durch eine Imgakomponente ( evtl. StringGrid )
2. Spiel Starten -> Schiffe zufällig auf dem Feld platzieren ( evtl mit Boolean ''True o. False'' )

Das ist das - ohne jetzt jemandem zu nahe zu treten - worüber ich die ganze Zeit spreche: wenn man kein Plan hat wie es am Ende aussehen soll, kann man auch kein Projektplan erstellen. Das ist wie eine USA Reise. Der Plan kann lauten: Ankunft Flughafen neue Stadt, Hotel einchecken, Stadt besuchen, Hotel auschecken, zum Flughafen, Fliegen, Ankunft Flughafen neue Stadt, Hotel einchecken, Stadt besuchen, Hotel auschecken, zum Flughafen, Fliegen, ... Sehr allgemein, für mich aber kein Plan. Wir wissen aber immer noch nicht welche Städte wir besuchen und was wir uns angucken.

Genauso ist es mit dem oberen Plan.

Zitat:

1. Generieren des Spielfeldes durch eine Imgakomponente ( evtl. StringGrid )

Wo? Wie? Man sollte sich entscheiden eine Array-Matrix zu nehmen oder evtl. StringGrid, denn schon hier entscheidet es sich wie man weiter vorgeht. Man sollte somit schon ein Plan haben was man nehmen wird, z. B. ein Imgakomponente, dann braucht man eine Array-Matrix, oder man verwaltet die X-en in einem StringGrid. Und bevor einer meint, mann kann auch mit einem StringGrid ein Feld anzeigen, dann vermisse ich bei Punkt ein das Generieren einer Matrix für das StringGrid.

1. Vorbereitung
1.1. ein Record für Array-Zellen generieren (damit hat man mehr Möglichkeiten)
1.2.1. eine Array-Matrix für das Spielfeld Spieler generieren
1.2.2. eine Array-Matrix für das Spielfeld Computer generieren
1.3. Spielanfang, alle Zellen löschen
1.4.1. Computer 10 Schiffe aufstellen lassen
1.4.1.1. Schiffspositionen zufällig generieren
1.4.1.2. Schiffsposition auf Überschneidung prüfen
1.4.1.3. Schiffsposition auf aneinander stoßen prüfen
1.4.1. Spieler 10 Schiffe aufstellen lassen
1.4.1.1. Schiffsposition auf Überschneidung prüfen
1.4.1.2. Schiffsposition auf aneinander stoßen prüfen
1.5. Grafikausgabe Spielerfeld
2. Spiel
...

[Sir Rufo]

@Popov

Wenn man sich die ganze Zeit an einem StringGrid verbeißt und auch nach gefühlten 20 Aufforderungen es nicht schafft ein Blatt Papier und Stift zu nehmen und das mal aufzumalen und durchzuspielen (mit Papier und Stift), ja dann rennt man tatsächlich planlos durch die Gegend.

Hast du bei meinen Grafiken irgendwo etwas von Array gelesen? Nein, wozu auch, das interessiert überhaupt nicht, in welcher Struktur ich das speicher (ich könnte das auch in einem String speichern)

Ich habe lediglich Überlegungen dazu angestellt, was beachtet werden muss, wie man die Positionierungs-Regeln umsetzt und was für einen Status die einzelnen Felder haben können.

Wenn ich diese Überlegungen hinter mir habe, dann mache ich mir Gedanken, ob ich da ein Array oder Liste oder Dictionary nehme ... aber dann bin ich schon bei der Umsetzung und klappere auf der Tastatur rum.

[leodinho]

Popov , ließt du dir meine Sachen eigl auch durch? ^^
Ich habe schon 3x geschrieben , dass ich kein Computer habe..
Außerdem geht es um die Planunf und nicht gleich um die Codierung ob ich Array nutze oder nicht..

@ Sir Rufo

Ich habe es aufgemalt aber hab halt wenig programmiert und mir fehlen halt die Zusammenhänge um es ordentlich zu planen ^^
Schonmal vielen dank für deine Zeit (:
Ich werde das Feld später mit einem StringGrid generieren obwohl ich noch nicht weiß wie das geht (hab dafür ja 2 monate zeit )
Zum zufälligen Positionieren wäre doch Boolean nützlich oder sehe ich das falsch? (dann könnte ich es kurz in der Planung erwähnen.. )

[Sir Rufo]

Zitat:

Zitat von leodinho (Beitrag 1243471)

Ich habe es aufgemalt aber hab halt wenig programmiert und mir fehlen halt die Zusammenhänge um es ordentlich zu planen ^^

Falsch, lass den ganzen Programmierkram komplett weg, der ist für den Plan nicht wichtig.
Stell dir einfach vor, du musst einer Person das Spiel "Schiffe Versenken" erklären, so dass er nachher den Part des Programms übernehmen kann. Dabei gibts du ihm auch ein paar Kniffe und Tricks mit, die du herausgefunden hast (siehe Positionierung eines Schiffes mit den Start-Koordinaten)

Zitat:

Zitat von leodinho (Beitrag 1243471)

Schonmal vielen dank für deine Zeit (:
Ich werde das Feld später mit einem StringGrid generieren obwohl ich noch nicht weiß wie das geht (hab dafür ja 2 monate zeit )

Das ist der richtige Ansatz. Es wird schon irgendwie anzuzeigen sein. Mal ein Bild mit dem Titel "So ungefähr soll es aussehen" und dann versucht man so nah wie möglich da dran zu kommen (zur Not wird halt alles komplett selber gezeichnet, wie Popo das am Beispiel von TicTacToe gezeigt hat). Aber im Moment spielt das keine Geige ;)

Zitat:

Zitat von leodinho (Beitrag 1243471)

Zum zufälligen Positionieren wäre doch Boolean nützlich oder sehe ich das falsch? (dann könnte ich es kurz in der Planung erwähnen.. )

Nein, in die Planung gehört:

1. Ermittlung der Orientierung (horizontal/vertikal) per Zufall
2. Ermittlung der Start-Koordinaten (X,Y) per Zufall
3. Wenn das Schiff mit der Orientierung und den Start-Koordinaten nicht in das Spielfeld passt dann wieder zu (1.)
4. Schiff in das Spielfeld übernehmen

[Popov]

Zitat:

Zitat von Sir Rufo (Beitrag 1243470)

Hast du bei meinen Grafiken irgendwo etwas von Array gelesen?

Nein, habe ich nicht.

Zitat:

Nein, wozu auch, das interessiert überhaupt nicht, in welcher Struktur ich das speicher (ich könnte das auch in einem String speichern)

Das ist es ja wo sich unsere Meinungen unterscheiden, denn entweder ich hab die Aufgabenstellung falsch verstanden und da soll keine KI rein, sondern es werden die X-en manuell erstellt und geprüft, oder das Programm soll intelligent sein. Vorausgesetzt das zweite, dann gibt es meinen Überlegungen nach zwei Möglichkeiten: man macht es klassisch, d. h. man setzt nur X-en oder der Computer kennt die Positionen der Schiffe. Bei der ersten Variante muss man tatsächlich vorher keine Überlegungen anstellen, die Schiffe werden später auf einem Feld platziert, die Zuordnung der Schiffe erfolgt im Spiel. Was man sich aber am Anfang an Arbeit spart, kommt, und das ist meine Meinung, später X-fach auf einen zurück. Denn nun muss man mit einer Logik Schiffe suchen und prüfen ob die unter sind. Die zweite Möglichkeit ist dagegen von anfang an zu wissen wo die Schiffe sind. Man prüft also nicht das Feld im eigentlichen Sinne, sondern die Schiffe, ob sie unter sind. Hier muss man am Anfang mehr Arbeit investieren und spart sich später die KI. Zumindest die zum Schiffe suchen.

Kommen wir zurück zu der Struktur. Man muss sich am Anfang für eine der beiden Varianten entscheiden, später geht schlecht. Somit ist es meiner Meinung nach nicht unwichtig wie man es später speichert.

[Popov]

Zitat:

Zitat von leodinho (Beitrag 1243471)

Ich habe schon 3x geschrieben , dass ich kein Computer habe..

Das habe ich schon gelesen, aber ich dachte das ist ein Scherz. Du sollst etwas programmieren, hast aber keinen Computer?

Vorausgesetzt du hast einen Computer, meinst aber keinen Computergegner zu haben, in dem Fall stellt sich die Frage was du da eigentlich programmieren sollst? Dann ist das eigentlich keine richtige Aufgabe.

[DeddyH]

Zitat:

Zitat von leodinho (Beitrag 1243168)

Also mein Ziel ist es ein Feld 12x12 zu generieren auf dem:
- 1 4er Schiff
- 2 3er Schiffe
- 2 2er Schiffe
- 2 1er Schiffe
zufällig angeordnet sind..
Dann soll mit jedem Klick ein Zähler laufen bis das Spiel gewonnen wurde um die Züge zu ermitteln..

Ich seh da nix von KI, wäre ja auch "leicht" übertrieben für den Wissensstand (eine "richtige" KI wäre BTW auch für meine eigenen Kenntnisse zumindest keine leichte Aufgabe).

[leodinho]

@ Popov

Das Ziel meines Programmes ist halt so wenig wie möglich züge zu brauchen um alle schiffe zu versenken. (:

@ Rufo
Das waere bis jetzt meine vorläufige Planung:

Projektplanung - ,,Schiffe versenken''


1. Generieren des Spielfeldes durch ein StringGrid

1.1. 12x12 Feld erstellen mithilfe ( vertikal A-L und horizontal 1-12 )

2. Spiel Starten -> Schiffe zufällig auf dem Feld platzieren ( evtl mit Boolean )

2.1. Zufällige Position ermitteln
2.1.1. Einschränkungen der Schiffe:
4er – Schiff horizontal: 4er – Schiff vertikal:
(Für die anderen Schiffe gilt die Einschränkung je nach Größe auch)
2.1.2. Position zulässig? -> Alle Regelbedingungen erfüllt?
3er Schiff + mehrere Schiffe schon platziert:
Es ist zu erkennen, dass aufgrund der Regel ,,kein Schiff darf ein anderes Schiff berühren'',die Anzahl der Plätze gesunken ist.
2.1.3. Ermitteln aller gültigen Start-Koordinaten und aus dieser Menge zufällig eine auswählen

3. Klick auf das Feld (Zähler +1) ( if ... then ; else ... )

3.1. Treffer? → Ja → Dann Überprüfung ob Schiff versenkt? → Ja -> Meldung

''Schiff versenkt'' // Nein? → nächster Klick

3.2. Treffer? → Nein → nächster Klick

4. Solange Wiederholen bis alle Schiffe getroffen wurden -> 3. wiederholen

4.1. Zähler nach jedem Klick auf dem Spielfled um 1 erhöhen

5. Alle Schiffe getroffen?

5.1. Wurden alle Schiffe getroffen? → Ja? → Meldung anzeigen: ''Alle Schiffe getroffen''

6. Erscheinen des Highscores

6.1. Highscore ( Liste der Besten Spieler ) erstellen
6.2. Anzeige des Highscores sobald der Spieler alle Schiffe versenkt hat
6.3. Anzeige eines Feldes zum Eingeben des Namens
6.4. Speicherung der Daten im Highscore

Die Bilder hab ich jetzt hier mal weggelassen..
In welchem Bereich könnte ich genauer werden?

[EWeiss]

Zitat:

In welchem Bereich könnte ich genauer werden?

Theorie ist das eine die Praxis eine andere..
Woher sollen wir wissen ob du dich überhaupt schon mal mit Delphi beschäftigt hast.

Ich hoffe hab jetzt nicht zu viel gesagt und jemand verärgert.

gruss

[DeddyH]

1. ist immer noch falsch. Zuerst die Logik, dann die Darstellung. Ob das letztendlich ein StringGrid wird, ein Array of TPanel oder ein TSchießMichTot, ist doch erst einmal vollkommen irrelevant.

[Popov]

KI hört sich gewaltig an, aber schon eine if Abfrage ist ein KI.

Zitat:

Also mein Ziel ist es ein Feld 12x12 zu generieren auf dem:
- 1 4er Schiff
- 2 3er Schiffe
- 2 2er Schiffe
- 2 1er Schiffe
zufällig angeordnet sind..
Dann soll mit jedem Klick ein Zähler laufen bis das Spiel gewonnen wurde um die Züge zu ermitteln..

Ok, nehmen wir das als Grundlage.

Zitat:

ein Feld 12x12 zu generieren

Ein Feld 12x12? Gibt es ein Feld Spiele? Entweder doch zwei Felder, womit dann die Liste ungenau wäre, oder doch ein Feld, dann kein Battleship.

[DeddyH]

Isses denn so schwer? Ein Spielfeld, auf das so lange geballert wird, bis alle Schiffe versenkt sind, zurückgeschossen wird nicht. Das entspricht zwar nicht dem klassischen Schiffe versenken, ist aber zumindest ähnlich.

[leodinho]

Du triffst es genau ! :D

[Sir Rufo]

Hier mal ein paar Ablaufdiagramme (und immer noch nix mit Programmierung)
Anhang 40527 Anhang 40528 Anhang 40529
(BTW: erstellt mit dem PAP-Designer)

[leodinho]

Ja eine Vereinfachung meiner Art. Warum bekomm ich das nicht gleich so konstant und gut hin ^^

Also ich denke damit sollte meine Planung insgesamt durch Ablaufplan + Ablaufdiagramme vollendet sein (:

[Sir Rufo]

Zitat:

Zitat von leodinho (Beitrag 1243479)

1. Generieren des Spielfeldes durch ein StringGrid

Falsch, denn

1. Daten werden nie, niemals, nicht in einem Control gespeichert. Ein Control ist für den Austausch mit dem Benutzer gedacht (Eingabe/Ausgabe)
2. Ob das wirklich ein StringGrid wird, ist ja noch gar nicht raus ... leg dich da einfach noch nicht fest. Und die Generierung des Spielfelds hat nichts mit der Anzeige zu schaffen.
   Die Anzeige folgt dem Spielfeld ;)

Zitat:

Zitat von leodinho (Beitrag 1243493)

Ja eine Vereinfachung meiner Art. Warum bekomm ich das nicht gleich so konstant und gut hin ^^

Weil du dich die ganze Zeit an einem StringGrid festgebissen hast und das Pferd von hinten aufzäumen wolltest, anstatt einfach erstmal das aufzuschreiben/aufzumalen, was du aus der Beschreibung und den Regeln zum Spiel "Schiffe Versenken" herausarbeiten kannst ;)