Discussion :

[Slowhand_]

Bonjour à tous,

J'essaie de coder une sorte de "Angry Birds". Je suis en train, en ce moment, de réaliser la partie projectile du projet. Autrement dit, j'aimerais pour l'instant simuler un point qui a une trajectoire parabolique et qui rebondit sur les parois de la fenêtre.
D'après ce que j'ai lu, le plus simple pour réaliser des jeux utilisant des équations physiques, est de "simplifier" ces équations. Ainsi, elles ne mettent pas en jeu le temps, mais seulement une approximation de l'évolution de la position et de la vitesse selon les deux axes du repère.

J'ai créé une classe Cprojectile caractérisant le projectile. Elle est définie comme suit :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
Type Cprojectile = class (CMObject)
fspeedy:integer; 
fspeedx:integer;
 
constructor create(aao:TStringList; awinw,awinh,apx,apy,aspeedx,aspeedy:integer;aangle:real);
procedure drawYourself(canv:TCanvas); override;
procedure move(); override;

fspeedy est la vitesse selon l'axe y et fspeedx est la vitesse selon l'axe x.

Comme vous pouvez le voir cette classe hérite d'une classe mère :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
type CMObject = class
 
     // position de l'objet
     fpx,fpy:integer;
 
     // Taille de la fenêtre
     fwinw,fwinh:integer;

Le mouvement du projectile est réalisé par la procédure suivante :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Procedure Cprojectile.move();
begin
      // gravité agissant sur la vitesse
     fspeedy := fspeedy + ACC;
     fspeedx := fspeedx;
 
     // mouvement de l'objet
     fpy := fpy + fspeedy;
     fpx := fpy + fspeedx;
 
     // rebonds
 
     if (fpy>=fwinh) or (fpy<=0) then fspeedy := -1*fspeedy;
     if (fpx<=0) or (fpx>=fwinw) then fspeedx:= -1*fspeedx;
 
end;

Enfin, la procédure suivante "dessine" le projectile :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
procedure Cprojectile.drawYourself(canv:TCanvas);
begin
     canv.Brush.color := clred;
     canv.Pen.color := clYellow;
     canv.rectangle(fpx,fpy,fpx+5,fpy+5);
end;

Je sais que ce n'est pas très évident de trouver ce qui cloche en ayant seulement une partie du code, mais bon... Ce dernier semble-t-il correct ? Lorsque je compile, les rebonds ne fonctionnent pas; le projectile reste bloqué lors d'un rebond.

Merci d'avance pour vos lumières.

[Archimède]

J'avais fait ça il y a un moment en delphi, si ça peut t'aider...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
 
unit Unit1;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, ExtCtrls;
 
type
  TForm1 = class(TForm)
    Timer1: TTimer;
    procedure Timer1Timer(Sender: TObject);
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  private
    { Déclarations privées }
    return,direct:boolean;
       R,sol,a,x,y:integer;
      vox,voy,v,t,ttotal,tchute,yo,amortissement:double;
       pt:Tpoint;
       FOND:Tbitmap;
    procedure rebondsouris;
  public
    { Déclarations publiques }
  end;
 
var
  Form1: TForm1;
 
implementation
 
{$R *.dfm}
procedure TForm1.FormDestroy(Sender: TObject);
begin
 fond.Free;
end;
 
procedure TForm1.rebondsouris;
begin
 x:=round(vox*ttotal)+R;
 if (y<=sol-R-20) and (a>0) then return:=false else return:=true;
 if not return then
 begin
   y:=round(0.5*a*sqr(t)+yo); //chute libre
  voy:=a*t;
  tchute:=t;
 end
 else
 begin
  a:=-abs(a);
  y:=round(sol-(0.5*a*sqr((t-tchute))+amortissement*voy*(t-tchute)))-20-R;
  v:=a*(t-tchute)+voy;
 
  if v<=0 then 
  begin
   a:=abs(a);
   t:=0;
   yo:=y;
  end;
end;
 
 t:=t+0.01;
 If (x>=fond.Width-R) then direct:=true;
 if direct then ttotal:=ttotal-0.01 else  ttotal:=ttotal+0.01;
 if x<R Then direct:=false;
 pt:=point(round(x),round(y));
 
 With Fond.canvas do
 begin;
  Pen.Width:=4;
  brush.color:=clblack;
  Fillrect(RECT(0,0,fond.Width,fond.Height));
  Brush.Color:=clgreen;
  fillrect(rect(0,Fond.height-20,Fond.width,Fond.height));
  pen.Color:=clyellow;
  brush.Color:=clyellow;
  ellipse(pt.X-R,pt.Y-R,pt.X+R,pt.Y+R);
 end;
 
end;
 
 
procedure TForm1.FormCreate(Sender: TObject);
begin
 Width:=screen.Width;
 height:=screen.Height;
 position:=poscreencenter;
 formstyle:=fsstayontop;
 Return:=false;
  R:=20;
  a:=3000;
  amortissement:=0.85;
  Fond:=Tbitmap.Create;
 
 with fond do 
 begin
  width:=Form1.ClientWidth;
  height:=Form1.ClientHeight;
 end;
 
 yo:=R;
 vox:=255;
 Pt:=point(20,20);
 sol:=Fond.Height;
end;
 
procedure TForm1.Timer1Timer(Sender: TObject);
begin
 rebondsouris;
 canvas.Draw(0,0,fond);
end;
end.

[Paul TOTH]

Voici une source qui pourra t'être utile

http://www.delphiforfun.org/programs/cannon_balls.htm

[mick605]

Salut

Je vois une petite erreur, surement due a un copier coller :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
     // mouvement de l'objet
     fpy := fpy + fspeedy;
     fpx := fpy + fspeedx;

Sinon, il faut faire attention, car tu travaille en "image par image". Ce que je veux dire, c'est que ton raisonnement est correct, mais il faut faire attention a plusieurs choses concernant les rebonds :

Un exemple pour commencer. On ne va raisonner que sur l'axe Y.
Ton projectile arrive vers le sol avec une vitesse fspeedY = -10.
Il est a fpY = 5. Acc vaut -10.

Lors de l'étape suivante, tu fais 
fspeedy := fspeedy + ACC; => fSpeedY = -20
fpy := fpy + fspeedy;     => fpY = -15
Le test (fpy<=0) est vérifié, donc
fspeedy := -1*fspeedy;    => fSpeedY = 20

Etape suivante :
fspeedy := fspeedy + ACC; => fSpeedY = 10
fpy := fpy + fspeedy;     => fpY = -5
Le test (fpy<=0) est vérifié, donc
fspeedy := -1*fspeedy;    => fSpeedY = -10

Etape suivante :
fspeedy := fspeedy + ACC; => fSpeedY = -20
fpy := fpy + fspeedy;     => fpY = -25
Le test (fpy<=0) est vérifié, donc
fspeedy := -1*fspeedy;    => fSpeedY = 20

Etape suivante :
fspeedy := fspeedy + ACC; => fSpeedY = 10
fpy := fpy + fspeedy;     => fpY = -15
Le test (fpy<=0) est vérifié, donc
fspeedy := -1*fspeedy;    => fSpeedY = 10

Tu remarques bien que ton fpY ne va pas... il te faut modifier ton test de rebond, et prendre en compte le sens dans lequel arrive ton projectile.

Une astuce maintenant : pour simuler l'amortissement de ton projectile dû au rebond, change

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
fspeedy := -0.8*fspeedy;
fspeedx := -0.8*fspeedx;

Un dernier conseil : dans un Memo (ou autre), marque au fur et a mesure les valeurs de tes différentes variables, comme ca, tu peux voir l'évolution de tes variables, et ainsi trouver lesquelles ne font pas ce que tu veux.

En espérant t'avoir aidé.

Bonne chance

[Slowhand_]

Merci à tous pour vos réponses!

Je vais essayer de corriger ce problème de rebond.