Hallo ihr Lieben!

Ich bin neu hier im Forum und auch in der Delphi Programmierung.^^ Wir haben es dieses Jahr in Informatik und sollen jeder eine Aufgabe erfüllen. Ich soll ein Billardspiel erzeugen und hänge grad ziemlich fest. Ich schaffe es schon, dass ich eine grüne Fläche und in den Ecken schwarze *Löcher* habe. Diese habe ich mit Shape erstellt, die Bälle werden via Canvas gezeichnet...

Es sind 4 Bälle im Moment. Mein Problem ist es jetzt, wie ich es schaffe diese Bälle verschieden farbig zu machen. Ich habe jetzt schon ziemlich viel bei Google gesucht und ausprobiert, mit Ball[1] und ähnlichem, aber entweder hat das garnicht funktioniert oder es hat sich nurnoch ein Ball bewegt

Auf jeden Fall bewegen sich die Bälle schonmal (Puuuh harte Arbeit^^)... jetzt fehlt mir nurnoch, dass sie verschiedene Farben haben.

Ja, bin ja noch ziemliche Anfängerin... von daher wäre es nett, wenn ihr euch ein bisschen auf einfachem Niveau haltet mit euren Antworten...

Hab jetzt einfach mal die Teile angegeben, um die es geht, denke ich. Wenn noch etwas fehlt, kann ich es gerne ergänzen.^^

zusammenfalten · markieren

Delphi-Quellcode:

CONST Max = 4;

var
  Spielfeld: TSpielfeld;
  Ball : array[1..Max] of tBall;
  i : Integer;
  Farbe: tColor;

procedure TSpielfeld.FormCreate(Sender: TObject); // Bälle zufällig auf dem Bildschirm erzeugen, ohne Bewegung, Rahmen zeichnen.
var i,j: integer; r,x,y,vx,vy : single;
 begin
  with Bild.Canvas do
      begin
      Brush.Color := clGreen;
      Pen.Color := clBlack;
      pen.width := 5;
      Rectangle(0, 0, Bild.Width, Bild.Height);
      end;
      for i := 1 to max do
      begin
      x := Random(Spielfeld.Bild.Width-50) + 25;
      y := Random(Spielfeld.Bild.Height-50)+ 25;
      vx := Random(5)-4; vy := Random(5)-4;
      Ball[i].Init(clWhite,x,y,vx,vy,20);
      Ball[i].ZeigeDich;
      end
end;


procedure tBall.ZeigeDich; // Bälle anzeigen
begin
 with Spielfeld.Bild.Canvas do
      begin
      pen.width := 2;
      Brush.Color := clRed;
      Pen.Color := clBlack;
      Ellipse(Round(x-r),Round(y-r),Round(x+r),Round(y+r));
      end;
end;

procedure tBall.BewegeDich; // Bälle bewegen, verschwinden lassen und neu zeichnen
  begin
  with Spielfeld.Bild do
         begin
         Canvas.Pen.Color := clGreen;
         Canvas.Brush.Color := clGreen;
         Canvas.Ellipse(Round(x-r),Round(y-r),Round(x+r),Round(y+r));
    x := x +vx;
    y := y + vy;
    if (x >Width-r-4) then
    begin x := Width-r-4;
    vx := -vx
    end;
 if x < r + 4 then
    begin x := r + 4;
    vx := -vx
    end;
 if (y >Height-r-4) then
    begin y := Height-r -4 ;
    vy := -vy
    end;
    if y < r + 4 then
    begin
    y := r + 4;
    vy := -vy;
    end;
      Canvas.Pen.Color := clBlack;
      Canvas.Brush.Color := clRed;
      Canvas.Ellipse(Round(x-r),Round(y-r),Round(x+r),Round(y+r));
      end;
end;

procedure TSpielfeld.Timer1Timer(Sender: TObject); // Alle Bälle rollen
begin
for i := 1 to max do
   begin
   Ball[i].ZeigeDich;
   Ball[i].BewegeDich;
   end;
Stoss;
for i := 1 to max do Ball[i].ZeigeDich;
end;

An welchen Stellen müsste ich denn etwas verändern, damit sie verschiedene Farben haben? Das Buch was wir haben finde ich ziemlich schlecht und unser Lehrer hat uns auch kaum was erklärt =(

Freue mich auf eure Antworten und danke schonmal im Voraus,

eure Undercover

Ein Billiardspiel ist meines Erachtens nach extrem komplex (Kugelkollisionen etc.) und damit völlig ungeeignet für einen Informatikkurs an einer Schule, v.a. nach nur einem Jahr.

Leider fehlen noch wichtige Deklarationen, kannst du ggf mehr Quellcode posten?

Naja es soll ja noch recht einfach bleiben. Ohne den ganzen Physikkram.

Ich post einfach mal alles.. Hab mich dabei extrem an das Buch gehalten und einigen Quellen, die ich bei google gefunden habe. Bestimmt ist das alles extrem kompliziert und falsch und unsauber... aber ich bin schonmal froh, dass es generell funktioniert.^^

zusammenfalten · markieren

Delphi-Quellcode:

unit Unit1;

interface

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

type
  TSpielfeld = class(TForm)
    GroupBox1: TGroupBox;
    Stop: TButton;
    Bewegen: TButton;
    Timer1: TTimer;
    Bild: TImage;
    Shape1: TShape;
    Shape2: TShape;
    Shape3: TShape;
    Shape4: TShape;
    procedure BewegenClick(Sender: TObject);
    procedure Timer1Timer(Sender: TObject);
    procedure StopClick(Sender: TObject);
    procedure FormCreate(Sender: TObject);
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;
type
tBall = class x,y,vx,vy,r : Single;
              farbe : tColor;
              procedure Init(fNeu: tColor;
                          xNeu,yNeu,vxNeu,vyNeu,rNeu : Single);
              procedure ZeigeDich;
              procedure BewegeDich;
              end;

CONST Max = 4;

var
  Spielfeld: TSpielfeld;
  Ball : array[1..Max] of tBall;
  i : Integer;
  Farbe: tColor;

implementation

{$R *.DFM}

procedure tBall.Init(fNeu: tColor;
                         xNeu,yNeu,vxNeu,vyNeu,rNeu: Single);
begin
farbe := fNeu;
r := rNeu;
x := xNeu;
y := yNeu;
vx := vxNeu;
vy := vyNeu;
end;

procedure TSpielfeld.FormCreate(Sender: TObject); // Bälle zufällig auf dem Bildschirm erzeugen, ohne Bewegung
var i,j: integer; r,x,y,vx,vy : single;
 begin
  with Bild.Canvas do
      begin
      Brush.Color := clGreen;
      Pen.Color := clBlack;
      pen.width := 5;
      Rectangle(0, 0, Bild.Width, Bild.Height);
      end;
      for i := 1 to max do
      begin
      x := Random(Spielfeld.Bild.Width-50) + 25;
      y := Random(Spielfeld.Bild.Height-50)+ 25;
      vx := Random(5)-4; vy := Random(5)-4;
      Ball[i].Init(clWhite,x,y,vx,vy,20);
      Ball[i].ZeigeDich;
      end
end;


procedure tBall.ZeigeDich; // Ball anzeigen
begin
 with Spielfeld.Bild.Canvas do
      begin
      pen.width := 2;
      Brush.Color := clRed;
      Pen.Color := clBlack;
      Ellipse(Round(x-r),Round(y-r),Round(x+r),Round(y+r));
      end;
end;

procedure tBall.BewegeDich; // Bälle bewegen, verschwinden lassen und neu zeichnen
  begin
  with Spielfeld.Bild do
         begin
         Canvas.Pen.Color := clGreen;
         Canvas.Brush.Color := clGreen;
         Canvas.Ellipse(Round(x-r),Round(y-r),Round(x+r),Round(y+r));
    x := x +vx;
    y := y + vy;
    if (x >Width-r-4) then
    begin x := Width-r-4;
    vx := -vx
    end;
 if x < r + 4 then
    begin x := r + 4;
    vx := -vx
    end;
 if (y >Height-r-4) then
    begin y := Height-r -4 ;
    vy := -vy
    end;
    if y < r + 4 then
    begin
    y := r + 4;
    vy := -vy;
    end;
      Canvas.Pen.Color := clBlack;
      Canvas.Brush.Color := clRed;
      Canvas.Ellipse(Round(x-r),Round(y-r),Round(x+r),Round(y+r));
      end;
end;



procedure Stoss; // Bälle anstoßen
var h,d : single; i,j: integer;
  begin

for i := 1 to max-1 do
  for j := i+1 to max do
     begin
     d:=sqrt(sqr(Ball[i].x-Ball[j].x)+sqr(Ball[i].y-Ball[j].y));
     if d <= Ball[i].r+Ball[j].r
        then begin
           h := Ball[i].vx; Ball[i].vx := Ball[j].vx; Ball[j].vx := h;
           h := Ball[i].vy; Ball[i].vy := Ball[j].vy; Ball[j].vy := h;
        end
     end
  end;

procedure TSpielfeld.BewegenClick(Sender: TObject); // Timer aktivieren
begin
if Bewegen.Caption = 'Bewegen' then
   begin
   Bewegen.Caption := 'Stoppen';
   Timer1.Enabled := True;
   end
 else begin
   Bewegen.Caption := 'Bewegen';
   Timer1.Enabled := False;
 end
end;

procedure TSpielfeld.Timer1Timer(Sender: TObject); // Alle Bälle rollen
begin
for i := 1 to max do
   begin
   Ball[i].ZeigeDich;
   Ball[i].BewegeDich;
   end;
Stoss;
for i := 1 to max do Ball[i].ZeigeDich;
end;


procedure TSpielfeld.StopClick(Sender: TObject); // Programm schließen
begin
Halt
end;


Initialization;
Randomize;
for i:=1 to max do ball[i] := tBall.Create;

Finalization;

for i:=1 to max do Ball[i].Destroy;
end.

Wenn ich das Programm laufen lasse, sieht das so aus

http://img117.imageshack.us/my.php?image=billardub0.jpg

Soweit so gut. Soll ja auch kein richtiges Billard sein sondern nur sone Art Simulation mit vernachlässigung der ganzen Physik da.

Was ich jetzt brauche, wäre ein weißer Ball und der Rest der Bälle anders farbig. Achja. Und die Bälle verschwinden noch nicht, wenn sie auf das Shape treffen. Aber da fummel ich noch dran herum.^^

Erstell Dir einfach eine Liste mit den verfügbaren Farben. Jeder Ball bekommt eine zufällige Farbe zugewiesen, anschließend wird diese Farbe aus der Liste gelöscht.

Zitat von DeddyH:

Erstell Dir einfach eine Liste mit den verfügbaren Farben. Jeder Ball bekommt eine zufällige Farbe zugewiesen, anschließend wird diese Farbe aus der Liste gelöscht.

Ja... ist zumindenst ein Vorschlag, der sich gut anhört...

Wäre es vielleicht möglich, einen kleinen Beispielcode zu zeigen, den ich mir dann zurecht schreiben kann?

FColors ist vom Typ TList. Hier färbe ich 4 Shapes ein.

zusammenfalten · markieren

Delphi-Quellcode:

procedure TForm1.FormCreate(Sender: TObject);
var i, cIndex: Integer;
begin
  Randomize;
  FColors := TList.Create;
  FColors.Add(Pointer(clWhite));
  FColors.Add(Pointer(clRed));
  FColors.Add(Pointer(clBlue));
  FColors.Add(Pointer(clYellow));
  for i := 1 to 4 do
    begin
      cIndex := Random(FColors.Count);
      //Hier dann halt die Bälle einfärben, ich mache das mit Shapes
      (FindComponent('Shape'+inttostr(i)) as TShape).Brush.Color := TColor(FColors[cIndex]);
      FColors.Delete(cIndex);
    end;
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  FColors.Free;
end;

zusammenfalten · markieren

Delphi-Quellcode:

procedure TSpielfeld.FormCreate(Sender: TObject);
var i,j,cIndex: integer; r,x,y,vx,vy : single;
 begin
 Randomize;
  FColors := TList.Create;
  FColors.Add(Pointer(clWhite));
  FColors.Add(Pointer(clRed));
  FColors.Add(Pointer(clBlue));
  FColors.Add(Pointer(clYellow));
  for i := 1 to max do
    begin
      cIndex := Random(FColors.Count);
      (FindComponent('Ball'+inttostr(i)) as TBall).Brush.Color := TColor(FColors[cIndex]);
      FColors.Delete(cIndex);
    end;

Was gehört denn oben bei type noch rein?

Der sagt mir jetzt, dass bei FColors := TList.Create; der linken Seite kein Wert zugewiesen werden kann



Danke schonmal für die Antwort.^^

Schreib mal in der Deklaration von TSpielfeld unter das private FColors: TList;

ich glaube das ist mir grad zu kompliziert... ich mach grad ne neue version.. mit shapes..^^ mal sehen ob das besser geht.

Zitat von Undercover:

ich glaube das ist mir grad zu kompliziert... ich mach grad ne neue version.. mit shapes..^^ mal sehen ob das besser geht.

Jetzt Mal langsam

markieren

Delphi-Quellcode:

procedure TSpielfeld.StopClick(Sender: TObject); // Programm schließen
begin
//Halt //Nicht mit dem Holzhammer!

  close; //Sondern Spielfeld schliessen
end;

Und dann nimmste in deiner CREATE zwei kleine Anpassungen vor

zusammenfalten · markieren

Delphi-Quellcode:

procedure TSpielfeld.FormCreate(Sender: TObject); // Bälle zufällig auf dem Bildschirm erzeugen, ohne Bewegung
var i,j: integer; r,x,y,vx,vy : single;
 ColorArray: array [1..max] of TColor = (clWhite, clYellow, clRed, clBlue); //Farbarray definieren
begin
  with Bild.Canvas do
      begin
      Brush.Color := clGreen;
      Pen.Color := clBlack;
      pen.width := 5;
      Rectangle(0, 0, Bild.Width, Bild.Height);

      end;
      for i := 1 to max do
      begin
      x := Random(Spielfeld.Bild.Width-50) + 25;
      y := Random(Spielfeld.Bild.Height-50)+ 25;
      vx := Random(5)-4; vy := Random(5)-4;
      Ball[i].Init(ColorArray[i] //und mit Initialisieren
                   ,x,y,vx,vy,20);
      Ball[i].ZeigeDich;
      end
end;