Sujet Précédent Sujet Suivant

Utilisation threads

Résolu
milomax91 Messages postés 10 Date d'inscription jeudi 19 février 2009 Statut Membre Dernière intervention 31 mars 2011 - 31 août 2009 à 03:28
milomax91 Messages postés 10 Date d'inscription jeudi 19 février 2009 Statut Membre Dernière intervention 31 mars 2011 - 31 août 2009 à 20:26
Bonjour a tous ,

J'ai un petit problème, je suis sur la création d'un jeux assez simple.
Animaux qui ce promène sur un fond d'écran et on tire avec la souris qui est la mire. Vous voyez le genre.

Vu qu'il y a plusieurs application en même temps il me faut utiliser les threads et là est mon problème.

Voici l'un des bout de code dont je doit utiliser un thread:
procedure TForm1.Timer1Timer(Sender: TObject);
begin
Anim := Anim + (1);

case Anim of
1: begin
ImgMout1.Picture := ImgMout2.Picture;
end;
2: begin
ImgMout1.Picture := ImgMout3.Picture;
end;
3: begin
ImgMout1.Picture := ImgMout4.Picture;
end;
4: begin
ImgMout1.Picture := ImgMout5.Picture;
end;
5: begin
ImgMout1.Picture := ImgMout6.Picture;
end;
6: begin
ImgMout1.Picture := ImgMout7.Picture;
end;
end;

if Anim >= 8 then Anim := 0

end;

Voici ce que j'ai essayé sans résultat :

type
TMoutonThread = class(TThread)
private
{ Déclarations privées }
ThreadCount,
ThreadCount2: Integer;
ImgMouTemp1,
ImgMouTemp2,
ImgMouTemp3,
ImgMouTemp4,
ImgMouTemp5,
ImgMouTemp6,
ImgMouTemp7:TImage;

protected
procedure execute;
procedure anime;
public
constructor Create (Count1:integer;Count2:integer;ImgTemp1:TImage;
ImgTemp2:TImage;ImgTemp3:TImage;ImgTemp4:TImage;
ImgTemp5:TImage;ImgTemp6:TImage;ImgTemp7:TImage);
end;

implementation

constructor TMoutonThread.Create(Count1:integer;Count2:integer;
ImgTemp1:TImage;ImgTemp2:TImage;
ImgTemp3:TImage;ImgTemp4:TImage;
ImgTemp5:TImage;ImgTemp6:TImage;
ImgTemp7:TImage);

begin
inherited Create(False); // lancer l'éxécution
ThreadCount:=Count1;
ThreadCount2:=Count2;
ImgMouTemp1:= ImgTemp1;
ImgMouTemp2:= ImgTemp2;
ImgMouTemp3:= ImgTemp3;
ImgMouTemp4:= ImgTemp4;
ImgMouTemp5:= ImgTemp5;
ImgMouTemp6:= ImgTemp6;
ImgMouTemp7:= ImgTemp7;
synchronize(execute);
end;

procedure TMoutonThread.execute;
begin
Synchronize (anime);
end;

procedure TMoutonThread.anime;
begin
ThreadCount := ThreadCount + (1);

case ThreadCount of
1: begin
ImgMouTemp1.Picture := ImgMouTemp2.Picture;
end;
2: begin
ImgMouTemp1.Picture := ImgMouTemp3.Picture;
end;
3: begin
ImgMouTemp1.Picture := ImgMouTemp4.Picture;
end;
4: begin
ImgMouTemp1.Picture := ImgMouTemp5.Picture;
end;
5: begin
ImgMouTemp1.Picture := ImgMouTemp6.Picture;
end;
6: begin
ImgMouTemp1.Picture := ImgMouTemp7.Picture;
end;
end;

if ThreadCount >= 8 then ThreadCount := 0
end;
end.

Pouvez-vous m'aider s.v.p

7 réponses

Réponse 1 / 7
Utilisateur anonyme
31 août 2009 à 06:35
Salut,

Ca ne peut pas fonctionner, au moins pour une raison toute simple, il n'y a pas de boucle .

Pourquoi ne pas lire le tuto de GrandVizir sur le sujet ?

Sinon un truc non testé : 

TMoutonThread = class(TThread)
  private
    ThreadCount1,ThreadCount2: Integer;
    ImgMouList:Array[1..7] Of TImage;
  protected
    procedure execute; Override;
    procedure anime;
  public
    constructor Create (Count1,Count2:integer; ImgTempList:Array Of TImage);
  end;

constructor TMoutonThread.Create (Count1,Count2:integer; ImgTempList:Array Of TImage);
Var
  IndexImg:Cardinal;
begin
  inherited Create(False);
  ThreadCount1:=Count1;
  ThreadCount2:=Count2;
  For IndexImg:=1 To 7 Do
  ImgMouList[IndexImg]:= ImgTempList[IndexImg];
end;

procedure TMoutonThread.Execute;
begin
  repeat
    Sleep(500);
    Synchronize(anime);
  until Terminated;
end;

procedure TMoutonThread.anime;
begin
  Inc(ThreadCount1 ,1);
  If ThreadCoun1<=6 Then
  ImgMouList[1]:=ImgMouList[ThreadCount1+1];
  if ThreadCoun1>= 8 then ThreadCount1 := 0;
end;


Je ne sais pas ce que tu cherches à faire mais utiliser des TImages ne me semble pas une bonne idée, car bonjour la lourdeur .

Par contre tu devrais mêttre a plat ce que tu veux faire, car en terme d'intéret, il y a des choses qui m'échappent dans ta stratégie.
3
Réponse 2 / 7
cs_cantador Messages postés 4720 Date d'inscription dimanche 26 février 2006 Statut Modérateur Dernière intervention 31 juillet 2021 13
31 août 2009 à 09:29
bonjour,

Un seul TImage et des Bitmap qui apparaissent aléatoirement..

cantador
0
Réponse 3 / 7
Cirec Messages postés 3833 Date d'inscription vendredi 23 juillet 2004 Statut Modérateur Dernière intervention 18 septembre 2022 50
31 août 2009 à 13:47
Nicolas__ n'est pas bien réveillé

j'avais mis le lien du Sprite Engine
que j'ai rebaptisé au passe en "Spirite-Engine"


[hr]@+Cirec
[hr]
0
Réponse 4 / 7
Nicolas___ Messages postés 992 Date d'inscription jeudi 2 novembre 2000 Statut Membre Dernière intervention 24 avril 2013 1
31 août 2009 à 14:04
oups ... le spirit engine , pas mal :)

ben vaut mieux répéter deux fois l'info que pas du tout

++
0

Vous n’avez pas trouvé la réponse que vous recherchez ?

Posez votre question
Réponse 5 / 7
f0xi Messages postés 4205 Date d'inscription samedi 16 octobre 2004 Statut Modérateur Dernière intervention 12 mars 2022 35
31 août 2009 à 17:55
non non non et non !

tu n'as pas besoin de thread! ça ne sert a rien dans ce cas!

tu as juste mal penser ta programmation.


deja, si tu utilise 50 TImage normal que ton programme soit lent.

il te faut afficher toutes les images dans le même objet, et l'un des meilleurs pour cela c'est TPaintBox.

exemple : 

unit Ducks;

interface


{$IF RTLVersion >= 18.0}
  {$DEFINE PNGIMG}
{$ELSE}
  {$DEFINE PNGLIB}
{$IFEND}


uses
  Windows, SysUtils, Classes, Graphics,
  {$IFDEF PNGIMG}PNGImage{$ELSE}PNGLib{$ENDIF};

{$IFDEF PNGLIB}
type
  TPNGImage = TPNGObject;
{$ENDIF}

{ Images d'arriere plan et d'avant plan }
const
  giBackPlan   = 0;
  giFrontPlan  = giBackPlan + 1;
  giMin        = giBackPlan;
  giMax        = giFrontPlan;

var
  GroundImages : array[giMin..giMax] of TPNGImage;
  GroundImagesLoaded : boolean = false;

procedure DrawBackGround(Canvas: TCanvas; X, Y: integer); inline;
procedure DrawFrontGround(Canvas: TCanvas; X, Y: integer); inline;

{ Images du viseur }
const
  miWait   = 0;
  miShoot  = miWait + 1;
  miReload = miShoot + 1;
  miMin    = miWait;
  miMax    = miReload;

var
  MireImages : array[miMin..miMax] of TPNGImage;
  MireImagesLoaded : boolean = false;

procedure DrawMire(Canvas: TCanvas; X, Y, Mire: Integer); inline;

{ Images des canards en mode :
    Vol de gauche à droite (LR)
    Vol de droite à gauche (RL)
    Tiré de gauche à droite (LR)
    Tiré de droite à gauche (RL)
}
const
  diModeLR = 0;
  diModeRL = 1;
  diFlyMin = 0;
  diFlyMax = 3;
  diShootedMin = 0;
  diShootedMax = 2;

var
  DuckImagesFly : array[diModeLR..diModeRL, diFlyMin..diFlyMax] of TPNGImage;
  DuckImagesFlyLoaded : boolean = false;

  DuckImagesShooted : array[diModeLR..diModeRL, diShootedMin..diShootedMax] of TPNGImage;
  DuckImagesShootedLoaded : boolean = false;

procedure DrawDuckFly(Canvas: TCanvas; X, Y, Dir, Frame: integer); inline;
procedure DrawDuckShooted(Canvas: TCanvas; X, Y, Dir, Frame: integer); inline;

type
  TDuck = class
  private
    fDir   : integer;
    fFrame : integer;
    fPos   : TPoint;
    fSpd   : integer;
    fCanvas: TCanvas;
    fState : integer;      // 0 fly, 1 shooted
    fOnDead: TNotifyEvent;
  public
    constructor Create(Canvas: TCanvas); // Ducks[n] := TDuck.Create(PaintBox1.Canvas);
    procedure Step; // a appeler dans evenement Timer1 -> OnTimer
    procedure Draw; // a appeler dans evenement PaintBox1 -> OnPaint ou procedure Form -> DrawBuffer
    function Shooted(const X,Y: integer): boolean; // a appeler dans evenement PaintBox1 -> OnMouseDown[mbLeft] ou
                                                   // procedure Form -> OnMouseDown[mbLeft]
  public
    property OnDead : TNotifyEvent read fOnDead write fOnDead; // assignez un evenement ici pour
                                                               // liberer le canard de la liste (TList, TObjectList)
  end;

implementation


procedure DrawBackGround(Canvas: TCanvas; X, Y : integer);
begin
  Canvas.Draw(X, Y, GroundImages[giBackPlan]);
end;

procedure DrawFrontGround(Canvas: TCanvas; X, Y : integer);
begin
  Canvas.Draw(X, Y, GroundImages[giFrontPlan]);
end;

procedure DrawMire(Canvas: TCanvas; X, Y, Mire: Integer);
begin
  Canvas.Draw(X - (MireImages[Mire].Width shr 1),
              Y - (MireImages[Mire].Height shr 1),
              MireImages[Mire]);
end;

procedure DrawDuckFly(Canvas: TCanvas; X, Y, Dir, Frame: integer);
begin
  Canvas.Draw(X - (DuckImagesFly[Dir, Frame].Width shr 1),
              Y - (DuckImagesFly[Dir, Frame].Height shr 1),
              DuckImagesFly[Dir, Frame]);
end;

procedure DrawDuckShooted(Canvas: TCanvas; X, Y, Dir, Frame: integer);
begin
  Canvas.Draw(X - (DuckImagesShooted[Dir, Frame].Width shr 1),
              Y - (DuckImagesShooted[Dir, Frame].Height shr 1),
              DuckImagesShooted[Dir, Frame]);
end;

{ Extention et chemin des images }
var
  imExt  : string = '.png';
  imPath : string = '';


{ Noms des images d'arriere plan et d'avant plan }
const
  giNames : array[giMin..giMax] of string =
            ('backplan','frontplan');


{ Noms des images du viseur }
const
  miNames : array[miMin..miMax] of string =
            ('mirewait','mireshoot','mirereload');


{ Noms des images des canards }
const
  diNamesFly : array[diModeLR..diModeRL, diFlyMin..diFlyMax] of string =
               (('LRF0','LRF1','LRF2','LRF3'),('RLF0','RLF1','RLF2','RLF3'));
  diNamesShooted : array[diModeLR..diModeRL, diShootedMin..diShootedMax] of string =
                   (('LRS0','LRS1','LRS2'),('RLS0','RLS1','RLS2'));


{ Chargement des Images
}
procedure LoadPictures;
var N, M : integer;
    F : string;
begin
  GroundImagesLoaded := true;
  for N := giMin to giMax do
  begin
    GroundImages[N] := TPNGImage.Create;
    F := imPath + giNames[N] + imExt;
    if FileExists(F) then
      GroundImages[N].LoadFromFile(F);
    GroundImagesLoaded := GroundImagesLoaded and not GroundImages[N].Empty;
  end;

  MireImagesLoaded := true;
  for N := miMin to miMax do
  begin
    MireImages[N] := TPNGImage.Create;
    F := imPath + miNames[N] + imExt;
    if FileExists(F) then
      MireImages[N].LoadFromFile(F);
    MireImagesLoaded := MireImagesLoaded and not MireImages[N].Empty;
  end;

  DuckImagesFlyLoaded := true;
  DuckImagesShootedLoaded := true;
  for M := diModeLR to diModeRL do
  begin
    for N := diFlyMin to diFlyMax do
    begin
      DuckImagesFly[M, N] := TPNGImage.Create;
      F := imPath + diNamesFly[M, N] + imExt;
      if FileExists(F) then
        DuckImagesFly[M, N].LoadFromFile(F);
      DuckImagesFlyLoaded := DuckImagesFlyLoaded and not DuckImagesFly[M, N].Empty;
    end;
    for N := diShootedMin to diShootedMax do
    begin
      DuckImagesShooted[M, N] := TPNGImage.Create;
      F := imPath + diNamesShooted[M, N] + imExt;
      if FileExists(F) then
        DuckImagesShooted[M, N].LoadFromFile(F);
      DuckImagesShootedLoaded := DuckImagesShootedLoaded and not DuckImagesFly[M, N].Empty;
    end;
  end;
end;


{ Déchargement des images
}
procedure UnloadPictures;
var N, M : integer;
begin
  GroundImagesLoaded := false;
  for N := giMin to giMax do
    GroundImages[N].Free;

  MireImagesLoaded := false;
  for N := miMin to miMax do
    MireImages[N].Free;

  DuckImagesFlyLoaded := false;
  DuckImagesShootedLoaded := false;
  for M := diModeLR to diModeRL do
  begin
    for N := diFlyMin to diFlyMax do
      DuckImagesFly[M, N].Free;

    for N := diShootedMin to diShootedMax do
      DuckImagesShooted[M, N].Free;
  end;
end;


{ Initialisation au debut du programme }
procedure Initialize;
begin
  imPath := ExtractFilePath(ParamStr(0))+'Images\';

  LoadPictures;
end;


{ Finalisation en fin de programme }
procedure Finalize;
begin
  UnloadPictures;
end;



{ TDuck }

constructor TDuck.Create(Canvas: TCanvas);
begin
  // le canvas doit etre valide
  assert(assigned(Canvas), 'TDuck.Create : Canvas ne peut être Nil.');
  fCanvas := Canvas;

  // direction aleatoire
  fDir    := random(100) mod 2;

  // position aleatoire
  fPos.X  := random(Canvas.ClipRect.Right-30)+30;
  fPos.Y  := random(Canvas.ClipRect.Bottom-200)+30;

  // vitesse aleatoire
  fSpd    := (random(100) mod 4) + 1;

  // frame de depart (la derniere)
  fFrame  := diFlyMax;

  // etat de depart (en vol)
  fState  := 0;
end;

procedure TDuck.Draw;
begin
  case fState of
    // en vol
    0 : DrawDuckFly(fCanvas, fPos.X, fPos.Y, fDir, fFrame);
    // tiré
    1 : DrawDuckShooted(fCanvas, fPos.X, fPos.Y, fDir, fFrame);
  end;
end;

function TDuck.Shooted(const X,Y: integer): boolean;
var PB : pByteArray;
begin
  // si le canard est déja tiré
  result :fState 1;
  // on sort
  if result then
    exit;

  // on recupere le cique du viseur
  PB := DuckImagesFly[fDir, fFrame].AlphaScanline[Y];

  // le canard ne peut etre tiré que si l'on a tiré dans une zone dont
  // la transparence est superieure a 128
  result := PB^[X] > $80;

  // si le canard est tiré on change l'etat d'animation
  if result then
    fState := 1;
end;

procedure TDuck.Step;
begin
  // mouvement du canard
  case fState of
    0 : // en vol
    begin
      fFrame := (fFrame + 1) mod (diFlyMax+1);
      case fDir of
        diModeLR : // de gauche a droite
        begin
          fPos.X := fPos.X + fSpd; // change la position
          // si on sort du cadre
          if fPos.X > (fCanvas.ClipRect.Right-30) then
          begin
            fDir := diModeRL; // change la direction
            fPos.X := fPos.X - fSpd; // reviens a la position d'avant
          end;
        end;
        diModeRL : // de droite a gauche
        begin
          fPos.X := fPos.X - fSpd; // change la position
          // si on sort du cadre
          if fPos.X < (fCanvas.ClipRect.Left+30) then
          begin
            fDir := diModeLR; // change la direction
            fPos.X := fPos.X + fSpd; // reviens a la position d'avant
          end;
        end;
      end;
    end;
    1 : // tiré
    begin
      // si on est a la derniere frame de la mort du canard
      if fFrame = diFlyMax then
      begin
        // on previens qu'il faut detruire le canard
        if Assigned(fOnDead) then
          fOnDead(Self);
      end
      else
        // sinon on continue l'animation
        fFrame := fFrame + 1;
    end;
  end;

end;




initialization
  Initialize;

finalization
  Finalize;

end.



je te laisse chercher le reste, mais ton programme doit ressembler a ça.
0
Réponse 6 / 7
Nicolas___ Messages postés 992 Date d'inscription jeudi 2 novembre 2000 Statut Membre Dernière intervention 24 avril 2013 1
31 août 2009 à 18:02
Le pauvre , lui qui voulait des moutons, vla qu'ils se mettent à voler maintenant

hum pas con de faire ça : fOnDead: TNotifyEvent;
0
Réponse 7 / 7
milomax91 Messages postés 10 Date d'inscription jeudi 19 février 2009 Statut Membre Dernière intervention 31 mars 2011
31 août 2009 à 20:26
Merci à vous,
votre aide à tous ma été très utile. Il me manquait qu'une boucle.


P.S Merci pour les liens de tutoriel et d'exemple.
0

Discussions similaires

Pb avg / group by
dmk04 -
DMK04 -

2 réponses
Requête avec un Group By
natlop -
crn_c21 -

1 réponse
Requête Union ALL avec group by spécifique.
cs_juha -
juha -

2 réponses
threads qui tournent en parallele
sparetime -
neodante -

2 réponses
générer le diagramme des classes à partir du diagramme des cas d'utilisation
dounatt -
12345fatma -

6 réponses
Rejoignez-nous