DelphiProjekt: Billard mit Reibungskugeln

[BOSUP]

Hallo miteinander,
ich weiß nicht ob ich es hier richtig gepostet habe, wenn nicht dann verschiebt bitte den Thread.

Also: Wir haben im Informatikunterricht über die letzten Monate ein Billardprogramm in verschiedenen Stufen geschriebem. Bisher habe ich das auch relativ gut hingegriegt. Nur bei der 6. Stufe habe ich ein paar Probleme. Es wäre super wenn ihr mir helft diese kleinen Porbleme zu lösen.

1.Stufe : Auf dem Billardtisch erscheint ein Tisch und darauf eine Kugel(ohne Bewegung). Ende mit Mausklick.
2.Stufe : Die Kugel soll sich bewegen.
3.Stufe : Die Kugel soll an der Bande abprallen.
4.Stufe : Es sollen mehrere Kugeln in unterschiedlicher Farbe, aus versch. Ausgangspositionen über den Tisch rollen.
5.Stufe : Es sollen zwei Kugeln über den Tisch rollen und an der Bande abprallen! Aber die Tischgröße soll auch verändert werden können!

6.Stufe : Die Kugeln sollen durch Reibung bedingt langsamer gemacht werden



Stufe 6 AWP

Delphi-Quellcode:

program pStufe4;

uses mSum,
  mKugel,
  mTisch,
  mReibungskugel in 'mReibungskugel.pas';


var
  mBildschirm : Bildschirm;
  mMaus : Maus;
  Tisch1 : tisch;
  Kugel1 : Kugel;
  Kugel2 : Kugel;
  meinTisch :tisch;



begin

  mBildschirm := Bildschirm.init;
  mMaus := Maus.init;
 
  Tisch1:=tisch.init(300,150,600,400) ;
  Kugel1:=kugel.init(tisch1.giblinks + 10,tisch1.giboben + 10,6,weiss,0.1,60) ;
  kugel1.merkeTisch(Tisch1) ;
  kugel2:=kugel.init(tisch1.giblinks + 50,tisch1.giboben + 50,6,weiss,0.5,60) ;
  kugel2.merkeTisch(Tisch1) ;
  Tisch1.zeigeDich;
  Kugel1.zeigeDich;
  Kugel2.zeigeDich;
  Repeat
        Kugel1.bewegedich;
        Kugel2.bewegedich;

  Until mMaus.istgedrueckt;

  Tisch1.versteckeDich;
  Kugel1.versteckeDich;
  Kugel2.versteckeDich;
 
  Tisch1.gibFrei;
  Kugel1.gibFrei;
  Kugel2.gibFrei;
  

  mMaus.gibFrei;
  mBildschirm.gibFrei;

end.

Klasse Tisch

Delphi-Quellcode:

unit mTisch;

interface
USES mSum;
type tisch=class
     private
            zlaenge,zbreite,zx,zy : zahl;
            hstift : Buntstift;
     Public
           constructor init(px,py,plaenge,pbreite : zahl);
           procedure zeigeDich;
           procedure versteckeDich;
           function gibrechts : zahl;
           function giblinks : zahl;
           function giboben : zahl;
           function gibunten : zahl;
           destructor gibFrei;
     end;
implementation
     constructor tisch.init(px,py,plaenge,pbreite : zahl);
                 begin
                      hstift := buntstift.init;
                      zlaenge := plaenge;
                      zbreite := pbreite;
                      zx := px;
                      zy := py;
                      hstift.bewegebis(zx,zy);
                 end;
     procedure tisch.zeigeDich;
               begin
                    hstift.setzefarbe(grau);
                    hstift.setzefuellmuster(1);
                    hstift.zeichneRechteck(zlaenge,zbreite);
               end;
     procedure tisch.versteckeDich;
               begin
                    hstift.setzefarbe(gruen);
                    hstift.zeichnerechteck(zlaenge, zbreite);
               end;
     function tisch.gibrechts;
              begin
                   result := zx+zlaenge;
              end;
     function tisch.giblinks;
              begin
                   result := zx;
              end;
     function tisch.giboben;
              begin
                   result := zy;
              end;
     function tisch.gibunten;
              begin
                   result := zy + zbreite;
              end;
     Destructor tisch.gibFrei;
               begin
                    self.versteckeDich;
                    hStift.gibFrei;
               end;
end.

Klasse Kugel

Delphi-Quellcode:

unit mKugel;

interface

uses msum,mTisch;

Type Kugel = class
     private
            zradius,zfarbe: GanzeZahl;
            zgeschwindigkeit,zrichtung,zx,zy: Zahl;
            hstift:buntstift;
            ktisch:tisch;
     public
           constructor init(px, py:zahl ; pradius, pfarbe:ganzezahl;pgeschwindigkeit,prichtung:zahl);
           procedure zeigedich;
           procedure versteckedich;
           procedure bewegedich;
           procedure setzerichtung(prichtung : zahl);
           procedure merkeTisch(pTisch:tisch);
           function gibx : zahl;
           function giby : zahl;
           function gibrichtung : zahl;
           destructor gibFrei;
     end;
implementation
     constructor Kugel.init(px, py:zahl ; pradius, pfarbe:ganzezahl; pgeschwindigkeit,prichtung:zahl);
                 begin
                      hstift := buntstift.init;
                      zradius := pradius;
                      zx := px;
                      zy := py;
                      zfarbe := pfarbe;
                      zgeschwindigkeit := pgeschwindigkeit;
                      zrichtung := prichtung;
                      hstift.bewegebis(zx,zy);
                      hstift.dreheUm(zrichtung);
                 end;
     procedure Kugel.zeigeDich;
               begin
                    hstift.setzeFarbe (zfarbe);
                    hstift.setzefuellmuster(1);
                    hstift.zeichneKreis(zradius);
               end;
     procedure Kugel.versteckeDich ;
               begin
                    hstift.setzefarbe(gelb);
                    hstift.zeichneKreis(zradius);
                    hstift.setzeFarbe (zfarbe);
               end;
     procedure Kugel.bewegeDich ;
               begin
                    if self.gibx > ktisch.gibrechts
                       then self.setzerichtung(180 - self.gibrichtung*2);
                    if self.gibx < ktisch.giblinks
                       then self.setzerichtung(180 - self.gibrichtung*2);
                    if self.giby > ktisch.gibunten
                       then self.setzerichtung(- self.gibrichtung * 2);
                    if self.giby < ktisch.giboben    
                       then self.setzerichtung(- self.gibrichtung * 2);
                    self.versteckedich;
                    hstift.bewegeum(zgeschwindigkeit);
                    self.zeigedich;
               end;
     procedure Kugel.setzerichtung (prichtung : zahl);
               begin
                    hstift.dreheum(prichtung);
               end;
     procedure kugel.merkeTisch(pTisch:tisch);
               begin
                    kTisch:=pTisch
               end ;
     function kugel.gibx ;
               begin
                     result := hstift.hposition;
               end;
     function kugel.giby ;
               begin
                    result := hstift.vposition;
               end;
     function kugel.gibrichtung ;
              begin
                   result := hstift.winkel;
              end;
     destructor Kugel.gibFrei;
                begin
                     self.versteckeDich;
                     hstift.gibFrei;
                end;
end.

Klasse Reibungskugel

Delphi-Quellcode:

unit mReibungskugel;

interface
         uses mSum, mKugel;

              type Reibungskugel = class (Kugel)

              private
                         zGeschwindigkeit:Zahl;
                         zReibung:Zahl;

              public
                    constructor init(px,py,pRadius,pGeschwindigkeit,pRichtung:Zahl;pFarbe:Zahl);OVERRIDE;
                    procedure bewegeDich (pGeschwindigkeit:Zahl);OVERLOAD;
                    procedure setzeReibung (pReibung:Zahl)
              end;
implementation
                 constructor Reibungskugel.init (px,py,pRadius,pGeschwindigkeit,pRichtung:Zahl;pFarbe:Zahl);
                             begin
                                  INHERITED init (px,py,pRadius,pGeschwindigkeit,pRichtung,pFarbe);
                                  zReibung :=0.01;
                             end;

                 procedure Reibungskugel.setzeReibung (pReibung:Zahl);
                           begin
                                zReibung:=pReibung;
                           end;
                 procedure Reibungskugel.bewegeDich (pGeschwindigkeit:Zahl);
                           begin
                                zGeschwindigkeit:=zGeschwindigkeit-zReibung;
                                INHERITED bewegeDich(zGeschwindigkeit);
                           end;

                
end.

Bitte helft mir den Programmcode so zu verändern das es funktioniert und die Kugeln langsamer werden. Habe die letzten Tage schon lange probiert.
Danke für jede Antwort.


Schöne Grüße

[Uwe Raabe]

Ich denke mal, dein Ansatz hier ist falsch:

Delphi-Quellcode:

                 
procedure Reibungskugel.bewegeDich (pGeschwindigkeit:Zahl);
begin
  zGeschwindigkeit:=zGeschwindigkeit-zReibung;
  INHERITED bewegeDich(zGeschwindigkeit);
end;

Du ziehst bei jeder Iteration eine Konstante Zahl von der Geschwindigkeit ab. Damit wird die Geschwindigkeit irgendwann mal negativ und auch unbegrenzt größer. Da ich nicht weiß, wie ein Buntstift auf negative Geschwindigkeit reagiert, kann ich das Ergebnis auch nicht vorhersagen.

Physikalisch ist Reibung proportional zur aktuellen Geschwindigkeit. Das kannst du einfach durch Multiplikation mit einem konstanten Faktor erreichen - z.B. so:

Delphi-Quellcode:

                 
procedure Reibungskugel.bewegeDich (pGeschwindigkeit:Zahl);
begin
  zGeschwindigkeit:=zGeschwindigkeit*(1 - zReibung);
  INHERITED bewegeDich(zGeschwindigkeit);
end;

[haentschman]

siehe auch Delphi Forum

[sx2008]

Auweia!!destructor gibFrei; Man darf dem Konstruktor einen beliebigen Namen geben, aber der Destruktor muss grundsätzlich immer Destroy heisen!
Beim Destruktor gilt der Satz "Es kann nur einen geben" und der sieht so aus:
destructor Destroy;override; PS: man kann's auch übertreiben mit der deutschen Sprache.
Mit Englisch kann man gerade beim Programmieren vieles knapper und besser ausdrücken.
tisch1.giblinks sieht für Delphi Programmierer irgendwie blöd aus.
tisch1.Left wäre Standardkonform.

[himitsu]

Das liegt aber auch mit an der ganzen Struktur...

Ich hab früher auch mal versucht auf "Deutsch" zu programmieren, aber dann kommt man schnell zu derartigen Namensproblemen, drum schreib ich jetzt vorwiegend nur noch auf Englisch.
Sieht auch gleich viel netter aus, ohne dieses ganze Denglich-Gemischmatsche (deutsch-englisch).

PS: Auch in der OH steht schon geschrieben "man ruft einen Destructor nicht direkt auf, sondern verwendet Free.
So, jetzt kann man sich auch leicht eine eigene gibFrei-Prozedur schreiben, welche praktisch das Selbe wie Free macht.

PSS: Leider liegt dieser Deutschwahn nichtmal an den Schülern, sondern an Lehrern, welche glauben, daß es so viel einfacher wäre.
(dabei käme man auf Englisch besser und man könnte dieses auch gleich noch mit dem Englischunterricht verknüpfen)

[fatalerror]

Zitat von himitsu:

Das liegt aber auch mit an der ganzen Structur...

Ich hab früher auch mal versucht auf "deutsch" zu programmieren, aber dann kommt man schnell zu derartigen Namensproblem, drum schreib ich jetzt vorwiegend nur noch auf englisch.
Sieht auch gleich viel netter aus, ohne dieses ganze Denglich-Gemischmatsche (deutsch-englisch).

PS: Auch in der OH steht schon geschrieben "man ruft einen Destructor nicht direkt auf, sondern verwendet Free.
So, jetzt kann man sich auch leicht eine eigene gibFrei-Prozedur schreiben, welche praktisch das Selbe wie Free macht.

PSS: leider liegt dieser Deutschwahn nichtmal an den Schülern, sondern an Lehrern, welche glauben, daß es so viel einfacher wäre.
(dabei käme man auf Englisch besser und man kann dieses auch gleich noch mit dem Englischunterricht verknüpfen)

@ himitsu
Wenn ich obigen Text lese und die Rechtschreibe- und Grammatikfehler zähle, verstehe ich, dass du auf englisch umgestiegen bist!

[Luckie]

Und warum heißt dein Konstruktor init?

[Uwe Raabe]

Zitat von Luckie:

Und warum heißt dein Konstruktor init?

Weil das schon unter Turbo/Borland-Pascal so war?