Eine Projektarbeit

[Sir Rufo]

Hier mal ein kleines Beispiel, wie man so etwas aufbauen und vor allem die Arbeit aufteilen kann:

Wir haben das Spiel Fang-Den-Button (ja, sehr sinnvoll)

Auf dem Spielfeld soll ein Button erscheinen und nach einer bestimmten Zeit die Position wechseln. Ziel ist es den Button zu treffen und nicht das Spielfeld. Für jeden getroffenen Button erhält man 10 Punkte. Trifft man mehr als 10 mal daneben, dann ist das Spiel vorbei.

Gemeinerweise verändert sich bei jedem Positionswechsel auch die Größe des Buttons und nach jedem Treffer wechselt der Button immer schneller seine Position.

Die Arbeit soll aufgeteilt werden, so dass einer sich um die Oberfläche und der Andere sich um die Logik kümmern kann. Dazu vereinbart man, was man wie und wo erwartet und skizziert sich folgende abstrakte Klasse (die kann quasi nix, gibt aber den Rahmen vor):

Delphi-Quellcode:

unit FangDenButton;

interface

uses
  System.Types,
  System.Classes;

type
  TFangDenButton = class abstract
  private
    FOnChange: TNotifyEvent; { System.Classes.TNotifyEvent }
    FPlaygroundSize: TPoint; { System.Types.TPoint }
    procedure SetOnChange( const Value: TNotifyEvent );
    procedure SetPlaygroundSize( const Value: TPoint );
  protected
    // Wird etwas geändert, dann diese Methode aufrufen,
    // damit die Anzeige darauf reagieren kann
    procedure NotifyChange( );
  protected
    // Konkrete Ableitungen müssen diese Methoden mit Leben füllen
    procedure DoButtonCatched; virtual; abstract;
    procedure DoButtonMissed; virtual; abstract;
    procedure DoStart; virtual; abstract;
    procedure DoSetPlaygroundSize( const Value: TPoint ); virtual;
    function GetPunkte: Integer; virtual; abstract;
    function GetPosition: TPoint; virtual; abstract;
    function GetButtonSize: TPoint; virtual; abstract;
    function GetSpielAktiv: Boolean; virtual; abstract;
  public
    // Button getroffen
    procedure ButtonCatched;
    // Button nicht getroffen
    procedure ButtonMissed;
    // Startet das Spiel
    procedure Start;

    // Ereignis bei einer Änderung
    property OnChange: TNotifyEvent read FOnChange write SetOnChange;
    // ANzahl der Punkte
    property Punkte: Integer read GetPunkte;
    // Position des Buttons
    property Position: TPoint read GetPosition;
    // Größe des buttons
    property ButtonSize: TPoint read GetButtonSize;
    // Größe des Spielfelds (wird von der Anzeige geliefert)
    property PlaygroundSize: TPoint read FPlaygroundSize write SetPlaygroundSize;
    // Ist das Spiel am laufen?
    property SpielAktiv: Boolean read GetSpielAktiv;
  end;

implementation

{ TFangDenButton }

procedure TFangDenButton.ButtonCatched;
begin
  DoButtonCatched;
end;

procedure TFangDenButton.ButtonMissed;
begin
  DoButtonMissed;
end;

procedure TFangDenButton.DoSetPlaygroundSize( const Value: TPoint );
begin
end;

procedure TFangDenButton.NotifyChange;
begin
  if Assigned( FOnChange )
  then
    FOnChange( Self );
end;

procedure TFangDenButton.SetOnChange( const Value: TNotifyEvent );
begin
  FOnChange := Value;
  if Assigned( FOnChange )
  then
    FOnChange( Self );
end;

procedure TFangDenButton.SetPlaygroundSize( const Value: TPoint );
begin
  if FPlaygroundSize <> Value
  then
    begin
      FPlaygroundSize := Value;
      // Wir benachrichtigen mal nach innen, wer weiß ob das benötigt wird
      DoSetPlaygroundSize( Value );
      // Vorsichtshalber informieren wir mal die Anzeige, man kann nie wissen :o)
      NotifyChange;
    end;
end;

procedure TFangDenButton.Start;
begin
  DoStart;
end;

end.

Nun können beide loslegen. Der für die Anzeige baut sich jetzt eine minimale funktionierende Klasse, damit er seine Anzeige auch testen kann

Delphi-Quellcode:

unit FangDenButtonTest;

interface

uses
  System.Types,
  FangDenButton;

type
  TFangDenButtonTest = class( TFangDenButton )
  private
    // Punkte
    FPunkte: Integer;
    // Spielstatus
    FSpielAktiv: Boolean;
  protected
    procedure DoButtonCatched; override;
    procedure DoButtonMissed; override;
    procedure DoSetPlaygroundSize( const Value: TPoint ); override;
    procedure DoStart; override;
    function GetButtonSize: TPoint; override;
    function GetPosition: TPoint; override;
    function GetPunkte: Integer; override;
    function GetSpielAktiv: Boolean; override;
  end;

implementation

{ TFangDenButtonTest }

procedure TFangDenButtonTest.DoButtonCatched;
begin
  inherited;
  // Punkte hochzählen
  Inc( FPunkte );
  // Anzeige benachrichtigen
  NotifyChange;
end;

procedure TFangDenButtonTest.DoButtonMissed;
begin
  inherited;
  // Punkte herunterzählen
  Dec( FPunkte );
  // Anzeige benachrichtigen
  NotifyChange;
end;

procedure TFangDenButtonTest.DoSetPlaygroundSize( const Value: TPoint );
begin
  inherited;
  // Anzeige benachrichtigen
  NotifyChange;
end;

procedure TFangDenButtonTest.DoStart;
begin
  inherited;
  // Punkte zurücksetzen, wenn das Spiel aktiv war
  if not FSpielAktiv
  then
    FPunkte := 0;
  // Einfaches umschalten zwischen an und aus
  FSpielAktiv := not FSpielAktiv;
  // Anzeige benachrichtigen
  NotifyChange;
end;

function TFangDenButtonTest.GetButtonSize: TPoint;
begin
  // Der Button bekommt die halbe Breite und Höhe des Spielfelds
  Result := TPoint.Create( PlaygroundSize.X div 2, PlaygroundSize.Y div 2 );
end;

function TFangDenButtonTest.GetPosition: TPoint;
begin
  // Der Button kommt in die Mitte des Spielfelds
  // eigentlich ( ( Spielfeld.Breite - Button-Breite ) / 2 )
  // aber da der halb so groß ist wie das Spielfeld (s.o.)
  // können wir auch vereinfacht ( Spielfeld.Breite / 4 ) nehmen
  Result := TPoint.Create( PlaygroundSize.X div 4, PlaygroundSize.Y div 4 );
end;

function TFangDenButtonTest.GetPunkte: Integer;
begin
  // Punkte zurückliefern
  Result := FPunkte;
end;

function TFangDenButtonTest.GetSpielAktiv: Boolean;
begin
  // Spielstatus zurückliefern
  Result := FSpielAktiv;
end;

end.

Damit baut er sich die Anzeige, die minimal so aussehen sollte

Delphi-Quellcode:

unit Form.Main;

interface

uses
  FangDenButton,

  Winapi.Windows, Winapi.Messages,
  System.SysUtils, System.Variants, System.Classes,
  Vcl.Graphics, Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Vcl.ExtCtrls, Vcl.Buttons;

type
  TForm1 = class( TForm )
  private
    // Die Spiel-Instanz
    FGame: TFangDenButton;
    // Benachrichtigungs-Methode wenn sich am Spiel etwas ändert
    procedure GameOnChange( Sender: TObject );
  public
    procedure AfterConstruction; override;
    procedure BeforeDestruction; override;
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

uses
  FangDenButtonTest;

{ TForm1 }

procedure TForm1.AfterConstruction;
begin
  inherited;
  // Spiel-Instanz erzeugen (ist erstmal die Test-Klasse)
  FGame := TFangDenButtonTest.Create;
  // Mit dem OnChange-Event verbinden
  FGame.OnChange := GameOnChange;
end;

procedure TForm1.BeforeDestruction;
begin
  // Spiel-Instanz wieder aufräumen
  FGame.Free;
  inherited;
end;

procedure TForm1.GameOnChange( Sender: TObject );
begin
  // Wird aufgerufen, wenn sich am Spiel etwas geändert hat
end;

end.

An Ende könnte das dann so aussehen

Delphi-Quellcode:

unit Form.Main;

interface

uses
  FangDenButton,

  Winapi.Windows, Winapi.Messages,
  System.SysUtils, System.Variants, System.Classes,
  Vcl.Graphics, Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, Vcl.ExtCtrls, Vcl.Buttons;

type
  TForm1 = class( TForm )
    PunkteLabel: TLabel;
    PlayGroundPanel: TPanel; 
      { OI: OnClick => PlaygroundPanelClick }
      { OI: OnDblClick => PlaygroundPanelClick }
      { OI: OnResize => PlaygroundPanelResize }
    HeaderPanel: TPanel;
    StartButton: TButton; 
      { OI: OnClick => StartButtonClick }
    FangButton: TSpeedButton; 
      { OI: OnClick => FangButtonClick }
    procedure FangButtonClick( Sender: TObject );
    procedure PlayGroundPanelClick( Sender: TObject );
    procedure StartButtonClick( Sender: TObject );
    procedure PlayGroundPanelResize( Sender: TObject );
  private
    FGame: TFangDenButton;
    procedure GameOnChange( Sender: TObject );
    procedure NotifyPlaygroundSize;
  public
    procedure AfterConstruction; override;
    procedure BeforeDestruction; override;
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

uses
  FangDenButtonTest;

{ TForm1 }

procedure TForm1.AfterConstruction;
begin
  inherited;
  FGame := TFangDenButtonTest.Create;
  FGame.OnChange := GameOnChange;
  NotifyPlaygroundSize;
end;

procedure TForm1.BeforeDestruction;
begin
  FGame.Free;
  inherited;
end;

procedure TForm1.FangButtonClick( Sender: TObject );
begin
  FGame.ButtonCatched;
end;

procedure TForm1.GameOnChange( Sender: TObject );
begin

  PunkteLabel.Caption := IntToStr( FGame.Punkte );

  FangButton.Visible := FGame.SpielAktiv;
  FangButton.Left := FGame.Position.X;
  FangButton.Top := FGame.Position.Y;
  FangButton.Width := FGame.ButtonSize.X;
  FangButton.Height := FGame.ButtonSize.Y;
end;

procedure TForm1.NotifyPlaygroundSize;
begin
  FGame.PlaygroundSize := TPoint.Create( PlayGroundPanel.Width, PlayGroundPanel.Height );
end;

procedure TForm1.PlayGroundPanelClick( Sender: TObject );
begin
  FGame.ButtonMissed;
end;

procedure TForm1.PlayGroundPanelResize( Sender: TObject );
begin
  NotifyPlaygroundSize;
end;

procedure TForm1.StartButtonClick( Sender: TObject );
begin
  FGame.Start;
end;

end.

Der Kollege mit der Logik ist dann auch soweit und bringt uns seine Unit FangDenButtonKonkret mit

Delphi-Quellcode:

unit FangDenButtonKonkret;

interface

uses
  System.Types,
  Vcl.ExtCtrls,
  FangDenButton;

type
  TFangDenButtonKonkret = class( TFangDenButton )
  private
    FTimer: TTimer; { Vcl.ExtCtrls.TTimer }
    FSpielAktiv: Boolean;
    FPunkte: Integer;
    FDaneben: Integer;
    FButtonSize: TPoint;
    FPosition: TPoint;
    procedure TimerCalled( Sender: TObject );
    procedure NewPosition;
    procedure SetButtonSize( ASize: Integer );
  protected
    procedure DoButtonCatched; override;
    procedure DoButtonMissed; override;
    procedure DoSetPlaygroundSize( const Value: TPoint ); override;
    procedure DoStart; override;
    function GetButtonSize: TPoint; override;
    function GetPosition: TPoint; override;
    function GetPunkte: Integer; override;
    function GetSpielAktiv: Boolean; override;
  public
    procedure AfterConstruction; override;
    procedure BeforeDestruction; override;
  end;

implementation

uses
  System.Math;

{ TFangDenButtonKonkret }

procedure TFangDenButtonKonkret.AfterConstruction;
begin
  inherited;
  FTimer := TTimer.Create( nil );
  FTimer.Enabled := False;
  FTimer.OnTimer := TimerCalled;
end;

procedure TFangDenButtonKonkret.BeforeDestruction;
begin
  FTimer.Free;
  inherited;
end;

procedure TFangDenButtonKonkret.DoButtonCatched;
begin
  inherited;
  if FSpielAktiv
  then
    begin
      FTimer.Enabled := False;
      FPunkte := FPunkte + 10;
      FTimer.Interval := Max( 150, FTimer.Interval - 50 );
      NewPosition;
      NotifyChange;
      FTimer.Enabled := True;
    end;
end;

procedure TFangDenButtonKonkret.DoButtonMissed;
begin
  inherited;
  if FSpielAktiv
  then
    begin
      Inc( FDaneben );
      if FDaneben = 10
      then
        begin
          FSpielAktiv := False;
        end;
      NotifyChange;
    end;
end;

procedure TFangDenButtonKonkret.DoSetPlaygroundSize( const Value: TPoint );
begin
  inherited;
  NewPosition;
end;

procedure TFangDenButtonKonkret.DoStart;
begin
  inherited;
  if not FSpielAktiv
  then
    begin
      FSpielAktiv := True;
      FPunkte := 0;
      FDaneben := 0;

      SetButtonSize( 100 );

      NewPosition;

      FTimer.Interval := 1000;
      FTimer.Enabled := True;
      NotifyChange;
    end;
end;

function TFangDenButtonKonkret.GetButtonSize: TPoint;
begin
  Result := FButtonSize;
end;

function TFangDenButtonKonkret.GetPosition: TPoint;
begin
  Result := FPosition;
end;

function TFangDenButtonKonkret.GetPunkte: Integer;
begin
  Result := FPunkte;
end;

function TFangDenButtonKonkret.GetSpielAktiv: Boolean;
begin
  Result := FSpielAktiv;
end;

procedure TFangDenButtonKonkret.NewPosition;
begin
  SetButtonSize( Random( 100 ) + 50 );
  FPosition.X := Random( PlaygroundSize.X - FButtonSize.X );
  FPosition.Y := Random( PlaygroundSize.Y - FButtonSize.Y );
  NotifyChange;
end;

procedure TFangDenButtonKonkret.SetButtonSize( ASize: Integer );
begin
  FButtonSize.X := ASize;
  FButtonSize.Y := ASize;
  NotifyChange;
end;

procedure TFangDenButtonKonkret.TimerCalled( Sender: TObject );
begin
  NewPosition;
end;

end.

Das ist nett, die werden wir doch gleich mal testen. Dazu müssen wir in unsere Anzeige nur ganz wenig ändern:

Delphi-Quellcode:

implementation

{$R *.dfm}

uses
  FangDenButtonTest,
  { Unit einbinden }
  FangDenButtonKonkret;

{ TForm1 }

procedure TForm1.AfterConstruction;
begin
  inherited;
  // FGame := TFangDenButtonTest.Create;
  // Statt der Test-Klasse, die Konkrete-Klasse
  FGame := TFangDenButtonKonkret.Create;
  FGame.OnChange := GameOnChange;
  NotifyPlaygroundSize;
end;

Und laufen lassen ...

Was sagt die Maus dazu?

Zitat:

Das war Delphi!

und eignet sich daher nicht zum Copy-Paste verwenden mit Lazarus/FreePascal!

[Sir Rufo]

Da habe ich doch gerade meine Animation Unit wiedergefunden und damit den FangButton animiert.
dp_182706.PNG
Das kompilierte Ergebnis ist im Anhang zu finden. Man wird feststellen, dass die Zeitabstände ein wenig zu hart verringert wird, denn bei ca. 13-15 Treffern (130-150 Punkten) ist irgendwie Schluss. Aber es ist ja nur ein Beispiel.

[Mavarik]

Soll TTT den von zwei Spieler gespielt werden oder gegen den Computer?

Soll Joshua auch Spieler Anzahl 0 können damit er lernt das der beste Spielzug - nicht zu spielen ist...?

Oder von 2 Spielern übers Netzwerk?

Soll einfach ein X oder O erscheinen oder soll das "malen" davon animiert werden?
Vielleicht eine Münze die sich dreht und dann den Wert zeigt?

Toll finde ich, dass Ihr schon festgelegt habt, dass ihr 2 TForms braucht... Cooles Konzept.

Überlegt Euch doch erst mal was es den werden soll.

Zitat von Jumpy:

Dieses trennen der Anzeige von der Logik ist dann bereits ein erstes Qualitätsmerkmal, dass der Lehrer hoffentlich zu würdigen weiß.

Ein frommer Wunsch... Wenn TTT mit Buttons im Unterricht realisiert wird...

[Felix Stein]

Zitat:

Soll TTT den von zwei Spieler gespielt werden oder gegen den Computer?

Soll Joshua auch Spieler Anzahl 0 können damit er lernt das der beste Spielzug - nicht zu spielen ist...?

Oder von 2 Spielern übers Netzwerk?

Soll einfach ein X oder O erscheinen oder soll das "malen" davon animiert werden?
Vielleicht eine Münze die sich dreht und dann den Wert zeigt?

Toll finde ich, dass Ihr schon festgelegt habt, dass ihr 2 TForms braucht... Cooles Konzept.

Überlegt Euch doch erst mal was es den werden soll.

Ich habe an ein ähnliches Prinzip wie wir es im Unterricht bereits verwendet haben gedacht 2 Spieler an einem Gerät. An ein Netzwerk ist vorerst nicht zu denken, ich kenne mich was das angeht nicht aus hätte aber gemutmaßt das das jeden Rahmen sprengt was Zeit und Skills angeht. Wir müssen uns ja alles Anlesen ^^ machen wir es also nicht komplizierter als unbedingt nötig.
Eine KI wird auf diese Art und Weise auch nicht benötigt wobei diese vielleicht gar keine schlechte Idee wäre

(auch hier stellt sich wieder die Frage ob Aufwand und Ergebnis das ganze Wert sind- eine funktionierende KI, unterumständen auch in zwei Varianten eine die das mittlere Feld frei lässt und eine die es benutzt (Schwer und leicht),wäre natürlich toll aber wir müssen auch noch ein anderes Spiel zum laufen bekommen).

Nun ja ich bekomme langsam eine Idee davon wie viel komplizierter, als neun Felder mit zwei Wahloptionen, das Ganze wohl wird.

Felix

[Sir Rufo]

Spätestens jetzt solltest du gemerkt haben, dass ein Konzept (was soll wie wo warum angezeigt werden) sehr hilfreich bei der Umsetzung in den echten Code ist.

Und dafür sind zunächst Papier und Bleistift (+ frisches Radiergummi) gefragt.

Einfach planlos drauflosklappern bringt nichts - oder eben ein Snake wofür es nur 6 Punkte gibt.

[BadenPower]

Zitat von Mavarik:

Soll Joshua auch Spieler Anzahl 0 können damit er lernt das der beste Spielzug - nicht zu spielen ist...?

Zu oft Wargames im Kino geschaut???


Sorry für OT, konnt ich mir nicht verkneifen, denn der Film ist irgendwie doch gut.

[Mavarik]

Zitat von BadenPower:

Zu oft Wargames im Kino geschaut???

War mir nicht sicher, ob "alle" alt genug sind für die Anspielung...

@Felix Stein...
hmm ob "mein Snakeland 3d" auch nur 6 Punkte bringen würde?
oder "Schiffe versenken"? Sind auch "nur" entstanden weil hier einer ne Frage hatte...

[OT]Das konnte ich mir jetzt nicht nehmen lassen[/OT]

[Felix Stein]

Morgen, wir melden uns mal wieder und sind jetzt schon ein ganzes stück weiter. Bis lang steht Tic Tac Toe und jetzt sitzen wir am Memory. Leider sitzen wir was das angeht aber in einer kleinen Misere wir wissen einfach nicht weiter. Ich werde das Programm unten anheften, vielleicht wisst ihr Rat wir haben keinen Plan wie wir folgendes Problem lösen sollen:

Feld mit Bild wird ausgewählt.
Zweites Feld mit Bild wird ausgewählt, keine Übereinstimmung.
Felder sollen zugedeckt werden.
Wir würden gerne vermeiden das der User das ganze manuell machen muss das verleitet ja zum Selbstbetrug (einfach die Felder offen lassen und hups ich bin der meister des Memory). wie immer ist uns Literatur lieber als eine Lösung wir wollen dieses Thema ja mit in das Literaturverzeichnis pack. Ich habe den Ordner als Zip verpackt hoffe das so alles funktioniert und danke schon mal im voraus für die Hilfe

MFG Felix

Ach ja Datei anhängen hat nicht funktioniert habe es als Zip verpackt aber da kommt leider eine Fehlermeldung (vermutlich ist die Datei zu groß)

unit Unit1;

{$mode objfpc}{$H+}

interface

uses
Classes, SysUtils, FileUtil, Forms, Controls, Graphics, Dialogs, ExtCtrls,
StdCtrls;

type

{ TForm1 }

TForm1 = class(TForm)
Button1: TButton;
Image1: TImage;
Image10: TImage;
Image12: TImage;
Image13: TImage;
Image14: TImage;
Image16: TImage;
Image18: TImage;
Image19: TImage;
Image2: TImage;
Image3: TImage;
Image4: TImage;
Image5: TImage;
Image6: TImage;
Image7: TImage;
Image8: TImage;
Image9: TImage;
procedure Button1Click(Sender: TObject);
procedure Image10Click(Sender: TObject);
procedure Image12Click(Sender: TObject);
procedure Image13Click(Sender: TObject);
procedure Image14Click(Sender: TObject);
procedure Image16Click(Sender: TObject);
procedure Image18Click(Sender: TObject);
procedure Image19Click(Sender: TObject);
procedure Image1Click(Sender: TObject);
procedure Image2Click(Sender: TObject);
procedure Image3Click(Sender: TObject);
procedure Image4Click(Sender: TObject);
procedure Image5Click(Sender: TObject);
procedure Image6Click(Sender: TObject);
procedure Image7Click(Sender: TObject);
procedure Image8Click(Sender: TObject);
procedure Image9Click(Sender: TObject);
private
{ private declarations }
public
{ public declarations }
end;

var
Form1: TForm1;
neuesBild:Integer=0;
listevonbildern:Array[0..7]of string =
('tulips.jpg',
'test.jpg',
'tulips.jpg',
'test.jpg',
'tulips.jpg',
'test.jpg',
'tulips.jpg',
'test.jpg');


implementation

{$R *.lfm}

{ TForm1 }

procedure TForm1.Button1Click(Sender: TObject);
begin
image1.Visible:=True;
image2.Visible:=True;
image2.Visible:=True;
image4.Visible:=True;
image5.Visible:=True;
image6.Visible:=True;
image7.Visible:=True;
image8.Visible:=True;
image9.Visible:=True;
image10.Visible:=True;
image12.Visible:=True;
image13.Visible:=True;
image14.Visible:=True;
image16.Visible:=True;
image18.Visible:=True;
image19.Visible:=True;


end;

procedure TForm1.Image10Click(Sender: TObject);
begin
Image10.Picture.LoadFromFile(ListevonBildern[neuesBild]);
inc(neuesBild);
if neuesBild> High(ListevonBildern)
then neuesBild :=Low(ListevonBildern);



end;

procedure TForm1.Image12Click(Sender: TObject);
begin
Image12.Picture.LoadFromFile(ListevonBildern[neuesBild]);
inc(neuesBild);
if neuesBild> High(ListevonBildern)
then neuesBild :=Low(ListevonBildern);
end;

procedure TForm1.Image13Click(Sender: TObject);
begin
Image13.Picture.LoadFromFile(ListevonBildern[neuesBild]);
inc(neuesBild);
if neuesBild> High(ListevonBildern)
then neuesBild :=Low(ListevonBildern);
end;

procedure TForm1.Image14Click(Sender: TObject);
begin
Image14.Picture.LoadFromFile(ListevonBildern[neuesBild]);
inc(neuesBild);
if neuesBild> High(ListevonBildern)
then neuesBild :=Low(ListevonBildern);
end;

procedure TForm1.Image16Click(Sender: TObject);
begin
Image16.Picture.LoadFromFile(ListevonBildern[neuesBild]);
inc(neuesBild);
if neuesBild> High(ListevonBildern)
then neuesBild :=Low(ListevonBildern);
end;

procedure TForm1.Image18Click(Sender: TObject);
begin
Image18.Picture.LoadFromFile(ListevonBildern[neuesBild]);
inc(neuesBild);
if neuesBild> High(ListevonBildern)
then neuesBild :=Low(ListevonBildern);
end;

procedure TForm1.Image19Click(Sender: TObject);
begin
Image19.Picture.LoadFromFile(ListevonBildern[neuesBild]);
inc(neuesBild);
if neuesBild> High(ListevonBildern)
then neuesBild :=Low(ListevonBildern);
end;

procedure TForm1.Image1Click(Sender: TObject);
begin
Image1.Picture.LoadFromFile(ListevonBildern[neuesBild]);
inc(neuesBild);
if neuesBild> High(ListevonBildern)
then neuesBild :=Low(ListevonBildern);
end;

procedure TForm1.Image2Click(Sender: TObject);
begin
Image2.Picture.LoadFromFile(ListevonBildern[neuesBild]);
inc(neuesBild);
if neuesBild> High(ListevonBildern)
then neuesBild :=Low(ListevonBildern);
end;

procedure TForm1.Image3Click(Sender: TObject);
begin
Image3.Picture.LoadFromFile(ListevonBildern[neuesBild]);
inc(neuesBild);
if neuesBild> High(ListevonBildern)
then neuesBild :=Low(ListevonBildern);
end;

procedure TForm1.Image4Click(Sender: TObject);
begin
Image4.Picture.LoadFromFile(ListevonBildern[neuesBild]);
inc(neuesBild);
if neuesBild> High(ListevonBildern)
then neuesBild :=Low(ListevonBildern);
end;

procedure TForm1.Image5Click(Sender: TObject);
begin
Image5.Picture.LoadFromFile(ListevonBildern[neuesBild]);
inc(neuesBild);
if neuesBild> High(ListevonBildern)
then neuesBild :=Low(ListevonBildern);

end;

procedure TForm1.Image6Click(Sender: TObject);
begin
Image6.Picture.LoadFromFile(ListevonBildern[neuesBild]);
inc(neuesBild);
if neuesBild> High(ListevonBildern)
then neuesBild :=Low(ListevonBildern);
end;

procedure TForm1.Image7Click(Sender: TObject);
begin
Image7.Picture.LoadFromFile(ListevonBildern[neuesBild]);
inc(neuesBild);
if neuesBild> High(ListevonBildern)
then neuesBild :=Low(ListevonBildern);
end;

procedure TForm1.Image8Click(Sender: TObject);
begin
Image8.Picture.LoadFromFile(ListevonBildern[neuesBild]);
inc(neuesBild);
if neuesBild> High(ListevonBildern)
then neuesBild :=Low(ListevonBildern);
end;

procedure TForm1.Image9Click(Sender: TObject);
begin
Image9.Picture.LoadFromFile(ListevonBildern[neuesBild]);
inc(neuesBild);
if neuesBild> High(ListevonBildern)
then neuesBild :=Low(ListevonBildern);
end;

end.
ich hoffe es geht auch so ansonsten muss ich es von zu Hause probieren.

[Felix Stein]

Ok, ok vergesst den letzten Beitrag.
Wir haben gerade mit unserem Lehrer geredet und haben einige neue Ideen bekommen um das ganze einfacher zu gestalten.

Grundsätzlich sollen wir für Tic Tac Toe und Memory das selber System benutzen.

Schritt eins: "Bilder im Hintergrund" deren Eigenschaften dann verändert werden. Funktioniert ja im Grunde genommen mit beiden Spielsystemen. Wie richten wir also am besten diese Bilder ein?

Schritt zwei: Eigenschaften verändern.

Unterteilt in Memory und Tic Tac Toe:

Memory: Wir haben zwei formen die das Bild annehmen kann Deckseite (bei allen 18 Bildern gleich) und Frontseite die eben aus 9 Paaren besteht. Wie wir die Bilder platzieren wissen wir ist nun auch keine mentale Höchstleistung doch wir wissen nicht mit welchem Befehl wir klar machen, das zwei Bilder zu einem Paar gehören oder eben nicht.

Tic Tac Toe:
Wir haben 3 Grundformen leeres Feld, Bild das X anzeigt und Bild das O anzeigt. Bei dem anderen Programm sind wir am Schluss hängen geblieben wo es dann hieß welche Kombinationen jetzt Sieg, Niederlage oder Unentschieden waren und dann wurde uns eben ans Herz gelegt mit den Bildern im Hintergrund zu arbeiten.

Schritt drei: der Feinschliff.

Memory: Uns fehlt die Funktion das wenn zwei Bilder nun aufgedeckt werden, aber kein paar sind und nun automatisch wieder verdeckt werden. Daran hapert es wir finden keine Befehlskette und raten hat noch keinem Programm geholfen (Literatur könnte schon helfen).

Tic Tac Toe: Wir müssen die Siegesbedingungen Festlegen sprich
-3 Hochkant, Seitlich oder Schräg
Wir haben uns darauf geeinigt "nur" ein manuell bedientes Tic Tac Toe zu erstellen sprich keine KI, man könnte also in der Theorie auch gegen sich selbst spielen. Unser einziges Problem ist nun also die Siegesbedingung.

Wir würden uns über baldige Antwort freuen und bedanken uns schon im Voraus