Discussion :

[sys1]

J'ai une difficulté assez insurmontable : Je voudrais créer un jeu d'aventure textuel avec un système de coordonnées (x,y) correpondant à une "carte" et des actions associées à chaque point x,y de la carte.

Le choix des actions se ferait avec des TButton, mais je ne sais pas comment "mettre en attente" la procédure contenant l'arborescence de chapitres (comme dans un livre-jeu) pendant que le programme attend que l'utilisateur clique sur le TButton 1,2,3 ou 4 (genre tourne à gauche ou à droite, ou demander à un npc quelque chose).

J'espère que c'est assez clair...

[nostroyo]

Je ne comprends pas bien ta question?

Mais as-tu bien compris la notion d'évenement en delphi? Tu as des évennements qui execute du code suivant une action ( un focus qui change, un clik sur un bouton...) Donc dans ton cas, utilise les evnt Onclick de tes boutons pour faire ton traitement. Pas besoin de 'faire attendre' une procédure, ce sont tes boutons qui 'commande' ton appli.

Je ne sais pas si ca t'aide ou si c'est à coté de la plaque!

Tiens nous au courant

[sys1]

En fait, je ne peux pas faire un évènement associé à chaque clic sur chaque bouton, puisque le résultat du click dépendra du "moment" de l'histoire.

Ce que je voudrais, c'est un truc dans ce genre :

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
procedure histoire(chapitre:Integer)
begin
if (chapitre=0) then 
     begin
 
           RichEdit1.Lines.Add('Voulez-vous...?');
           if click button 1 then
            begin
             ...
             chapitre:=1;
           end;
 
           if click button 2 then
            begin
            ...
            chapitre:=2;
            end;
    end;
 
if (chapitre=1) then 
    begin
    .....
    end;
 
if (chapitre=...) then
begin ... end;
...
end;

[Paul TOTH]

Ce que je voudrais, c'est un truc dans ce genre :

non tu peux pas comme ça

mais comme ça par exemple:

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
 
type
  TForm1 = class(TForm)
    Button1: TButton;
    procedure Button1Click(Sender: TObject);
  private
    { Private declarations }
    Chapitre:integer;
  public
    { Public declarations }
  end;
 
...
 
procedure TForm1.Button1Click(Sender: TObject);
begin
// que se passe-t-il quand on clique sur le bouton 1
 case Chapitre of 
 // dans le chapitre 1
   1 : begin
     RichEdit1.Lines.Add('Quand vous ouvrez la porte...')
     Chapitre:=2;
   end;
 // dans le chapitre 2
   2: begin
     RichEdit1.Lines.Add('Vous refermez la porte...')
     Chapitre:=1;
   end;
 // ...
 end;
end;

[sys1]

Merci, j'avais pas pensé à ça!
Comme quoi, j'avais pas un problème de syntaxe, mais d'algorithmique.
Bon, j'ai plus qu'à m'y mettre

[sjrd]

mais comme ça par exemple:

Ouh la belle machine à états qui va être un cauchemar à maintenir dès qu'il aura plus de 10 chapitres

En fait ce problème est un cas typique dans lequel on veut une coroutine. Car côté IHM, ce sont les boutons qui commandent les actions, et côté histoire, on veut aussi pouvoir commander l'usage des boutons Mais malheureusement, on ne peut pas commander des deux côtés.

J'ai implémenté, avec de l'inspiration venue de codes sur Internet, une gestion des coroutines que je trouve très bien faite
http://sepi.svn.sourceforge.net/view...as?view=markup
Tu n'as pas besoin de comprendre comment cette unité fonctionne à l'intérieur : c'est assez high-level Mais tu peux t'en servir comme ceci.

Avec ça, tu peux "écrire ton histoire" comme une classe descendante de TCustomCoroutine :

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
unit TheStory;
 
interface
 
uses
  ScCoroutines, ComCtrls;
 
type
  TMyStory = class(TCustomCoroutine)
  private
    FButtonClicked: Integer;
    FRichEdit: TRichEdit;
  protected
    procedure Execute; override;
 
    function AskForButton: Integer;
 
    property RichEdit: TRichEdit read FRichEdit;
  public
    constructor Create(ARichEdit: TRichEdit);
 
    procedure BeginStory;
    procedure ClickAButton(Button: Integer);
  end;
 
implementation
 
constructor TMyStory.Create(ARichEdit: TRichEdit);
begin
  inherited Create;
  FRichEdit := ARichEdit;
end;
 
procedure TMyStory.Execute;
begin
  RichEdit.Lines.Add('Début de l''histoire');
  RichEdit.Lines.Add('Appuyez sur un bouton');
  case AskForButton of
    1: RichEdit.Lines.Add('Bouton 1');
    2: RichEdit.Lines.Add('Bouton 2');
  end;
  RichEdit.Lines.Add('Voulez-vous ouvrir la porte ?');
  case AskForButton of
    1: RichEdit.Lines.Add('Vous ouvrez la porte.');
    2: RichEdit.Lines.Add('Vous passez votre chemin.');
  end;
  RichEdit.Lines.Add('L''histoire est finie');
end;
 
function TMyStory.AskForButton: Integer;
begin
  Yield;
  Result := FButtonClicked;
end;
 
procedure TMyStory.BeginStory;
begin
  Invoke;
end;
 
procedure TMyStory.ClickAButton(Button: Integer);
begin
  FButtonClicked := Button;
  Invoke;
end;
 
end.

Après, sur ta fiche, tu peux faire comme ça :

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
unit AventureMain;
 
interface
 
uses
  PleinDeChoses, TheStory;
 
type
  TFormMain = class(TForm)
    RichEdit: TRichEdit;
    Button1: TButton;
    Button2: TButton;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure ButtonClick(Sender: TObject);
  private
    Story: TMyStory;
  end;
 
implementation
 
procedure TFormMain.FormCreate(Sender: TObject);
begin
  Story := TMyStory.Create(RichEdit);
  Story.BeginStory;
end;
 
procedure TFormMain.FormDestroy(Sender: TObject);
begin
  Story.Free;
end;
 
procedure TFormMain.ButtonClick(Sender: TObject);
var
  Button: Integer;
begin
  Button := TButton(Sender).Tag;
  Story.ClickAButton(Button);
end;

Ici je compte sur le fait que tu as renseigné la propriété Tag des deux boutons respectivement avec 1 et 2.

Code testé et approuvé

[Paul TOTH]

ah mon dieu !

la dernière fois que j'ai fait ce genre de chose c'était pour faire du simili multitache sous Borland Pascal...en DOS donc

c'est assez amusant comme code en fait

mais bon, en vrai, pour un jeu dont vous êtes le héro, il faudrait plutôt partir sur un pseudo langage, car rédiger en Pascal tout cela ça va vite devenir pénible.

en plus ce langage n'a pas besoin de grand chose...juste les liens entre les chapitres, et j'ajouterais sans doute des variables d'état (il faut que j'ai la clé pour ouvrir la porte).

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
 
VAR CLEF // variable d'état
 
begin 0   // début de l'histoire
 LET CLEF=0 // pas de clef
 goto 1  // chapitre 1
end
 
begin 1 // chapitre 1
 "Vous êtes devant une porte" // texte à afficher
 "1) ouvrir la porte"
 "2) regarder sous le paillasson"
 On 1 goto 2
 On 2 goto 3
end // fin chapitre
 
begin 2
 if CLEF=0 then
  "Vous n'avez pas la clef !"
  goto 1
 else
  "Vous ouvrez la porte"
  goto 4
 end
end
 
begin 3
 "Vous trouvez une clef !"
 LET CLEF=1
 goto 1
end

[sjrd]

ah mon dieu !

Tu peux m'appeler Sébastien

la dernière fois que j'ai fait ce genre de chose c'était pour faire du simili multitache sous Borland Pascal...en DOS donc

Ben moi je suis constamment dans ce genre de choses Forcément, à vouloir coder un moteur de script de la mort qui tue, on découvre des choses

c'est assez amusant comme code en fait

Lequel, l'unité ScCoutines ou la façon dont on s'en sert ?

mais bon, en vrai, pour un jeu dont vous êtes le héro, il faudrait plutôt partir sur un pseudo langage, car rédiger en Pascal tout cela ça va vite devenir pénible.

en plus ce langage n'a pas besoin de grand chose...juste les liens entre les chapitres, et j'ajouterais sans doute des variables d'état (il faut que j'ai la clé pour ouvrir la porte).

Oui c'est vrai, il y a une conception douteuse à la base, mais coder un interpréteur, même simple, n'est pas forcément facile

[Paul TOTH]

Tu peux m'appeler Sébastien

haha ! d'habitude c'est moi qui la fait celle la

Ben moi je suis constamment dans ce genre de choses Forcément, à vouloir coder un moteur de script de la mort qui tue, on découvre des choses

Lequel, l'unité ScCoutines ou la façon dont on s'en sert ?

oui je parle de ton unité, en fait ça ne me serait pas venu à l'esprit d'utiliser cette technique dans un environnement multitache...mais oui pourquoi pas Je serais sans doute parti sur du multithread avec des semaphore ou des suspension de thread...mais bon, je n'ai eu besoin de ce mode de task switching qu'à l'époque du DOS

Oui c'est vrai, il y a une conception douteuse à la base, mais coder un interpréteur, même simple, n'est pas forcément facile

oh c'est jamais que de l'interprétation de chaine de caractère avec une syntaxe aussi simple que nécessaire. Et il serait même encore plus simple de créer un éditeur de scénario, auquel cas il ne reste plus qu'à définir un format de fichier

[sys1]

Je passe par le delphi car cela me permet d'afficher des images en fonction du lieu visité, de jouer un son ou une musique, de se déplacer dans toutes les directions sur une grande carte, de combattre des ennemis en utilisant les armes d'un inventaire et éventuellement des compagnons rencontrés précédemment.

Un simple éditeur de scénario intéractif ne me permettrait pas tout ça... J'ai une souplesse très grande, mais cela a un prix, c'est celui de l'apprentissage du delphi.

L'arborescence de chapitres n'est pas forcemment complexe car il y a plusieurs arborescences correspondant à chaque lieu visité et non pas une seule arborescence pour tout le jeu.
C'est la raison pour laquelle j'espère ne pas transformer le programme en machine à gaz...

[Paul TOTH]

Je passe par le delphi car cela me permet d'afficher des images en fonction du lieu visité, de jouer un son ou une musique, de se déplacer dans toutes les directions sur une grande carte, de combattre des ennemis en utilisant les armes d'un inventaire et éventuellement des compagnons rencontrés précédemment.

Un simple éditeur de scénario intéractif ne me permettrait pas tout ça... J'ai une souplesse très grande, mais cela a un prix, c'est celui de l'apprentissage du delphi.

mais si

il suffit que l'éditeur te propose en plus du texte, le nom d'une image et d'un fichier son à jouer

en plus si tu fais une compilation de toutes les informations dans un fichier dont tu détermines le format, l'application delphi n'est alors plus qu'un interpréteur de scénario...et pour peu que tu documentes un peu les format de ton fichier de jeu, d'autres programmeurs pourront s'amuser à porter l'interpréteur sur d'autres plateformes ou d'autres langages (Java, Flash...)

c'est ce qu'il se passe avec Scumm

[ShaiLeTroll]

Je n'ai pas vu de proposition avec la publication de méthode

On peut supposer que c'est toujours la même cinématique, une question dans un mémo, et un RadioGroup pour chaque réponse et le bouton de validation, on ajouter un TImage pour la carte, un TImage pour le contexte et un appel à PlaySound en Asynchrone ...

Tient, un code qui te permerttrait d'aller assez loin ... tu peux le copier, il compile et fonctionne sur Delphi 6

Et de gérer l'ensemble par les Evènements (Yield c'est plus low-tech que High-Tech... sjrd, lol on est plus en win 3.1, je trouve aussi le code assez dingue ... mais très interessant techniquement)

Donc pas de Sémaphore, de Thread, de truc compliqué (autre que MethodAdress), mais la confiance en méthode Application.Run ...

Si l'on ne code pas toute la séquence en dur, une StepReponseGeneric pourrait consulter un fichier pour faire son aiguillage, ... d'ailleurs, si c'est à chaque fois la même chose (disons que l'on fait apparaitre ou disparaitre des boutons ...), on aurait aussi une fonction StepCommon qui lirait aussi un fichier, et si le traitement est trop complexe ou non-standard, on pourrait appeler une méthode publiée plus spécifique ...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
procedure TMainForm.BtnStartClick(Sender: TObject);
var
  TextGameForm: TTextGameForm;
begin
  TextGameForm := TTextGameForm.Create(nil);
  with TextGameForm do
  try
    TTextGameEngine.Start(TextGameForm);
    ShowModal();
  finally
    Free();
  end;
end;

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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
unit uTextGameEngine;
 
interface
 
uses Classes, SysUtils, Controls,
  Frm_TextGame;
 
type
  TTextGameStep = procedure() of object;
 
  TTextGameEngine = class(TPersistent)
  private
    FTextGameForm: TTextGameForm;
    FEtape: Integer;
    procedure FirstStep;
    function CheckStep(RequireStep: Integer): Boolean;
    procedure NextStep(RequireStep: Integer);
    class function Singleton: TTextGameEngine;
  public
    constructor Create();
    destructor Destroy();
    class procedure Start(ATextGameForm: TTextGameForm);
    class procedure Stop();
  published
    procedure Step1(); 
    procedure StepReponse1(Sender: TObject);
    procedure Step2();
    procedure StepReponse2(Sender: TObject);
    procedure Step3();
    procedure Step4();
    procedure Step5();
  end;
 
implementation
 
var
  _TextGameEngine: TTextGameEngine;
 
constructor TTextGameEngine.Create();
begin
  if Assigned(_TextGameEngine) then
    _TextGameEngine.Free();
  _TextGameEngine := Self;
 
  inherited;
end;
 
destructor TTextGameEngine.Destroy();
begin
  _TextGameEngine := nil;
 
  inherited;
end;
 
class function TTextGameEngine.Singleton: TTextGameEngine;
begin
  Result := _TextGameEngine;
end;
 
class procedure TTextGameEngine.Start(ATextGameForm: TTextGameForm);
begin
  TTextGameEngine.Create();
 
  Singleton.FTextGameForm := ATextGameForm;
  Singleton.FirstStep();
end;
 
class procedure TTextGameEngine.Stop();
begin
  Singleton.FEtape := -1;
  Singleton.FTextGameForm.BtnOK.OnClick := nil;
  Singleton.FTextGameForm.BtnOK.ModalResult := mrOK;
  Singleton.FTextGameForm.BtnOK.Caption := 'Quitter';
end;
 
procedure TTextGameEngine.FirstStep();
begin
  NextStep(1);
end;
 
function TTextGameEngine.CheckStep(RequireStep: Integer): Boolean;
begin
  Result := RequireStep = FEtape;
end;
 
procedure TTextGameEngine.NextStep(RequireStep: Integer);
var
  AddressMethod: TMethod;
begin
  FEtape := RequireStep;
  AddressMethod.Code := Self.MethodAddress(Format('Step%d', [FEtape]));
  AddressMethod.Data := Self;
  if Assigned(AddressMethod.Code) then
    TTextGameStep(AddressMethod)()
  else
    Stop;
end;
 
procedure TTextGameEngine.Step1();  
begin
  if CheckStep(1) then
  begin
    FTextGameForm.MemoQuestion.Text := 'Quelle est la Réponse à la Question 1 ?';
    FTextGameForm.RadioResponses.Items.BeginUpdate();
    FTextGameForm.RadioResponses.Items.Clear();
    FTextGameForm.RadioResponses.Items.Add('A - Il n''y pas de Réponse');
    FTextGameForm.RadioResponses.Items.Add('B - L''Oiseau picore des graines');
    FTextGameForm.RadioResponses.Items.Add('C - Le Chat est parti');
    FTextGameForm.RadioResponses.Items.Add('D - La Réponse D');
    FTextGameForm.RadioResponses.Items.EndUpdate();
    FTextGameForm.BtnOK.OnClick := StepReponse1;
  end;
end;
 
procedure TTextGameEngine.StepReponse1(Sender: TObject);
begin
  if CheckStep(1) then
  begin
    case FTextGameForm.RadioResponses.ItemIndex of
      0: NextStep(2);
      1: NextStep(3);
      2: NextStep(4);
      3: NextStep(5)
      else
        Step1();
    end;
  end;
end;
 
procedure TTextGameEngine.Step2();  
begin
  if CheckStep(2) then
  begin
    FTextGameForm.MemoQuestion.Text := 'Quelle est la Réponse à la Question de l''Univers, de la vie et du reste ?';
    FTextGameForm.RadioResponses.Items.BeginUpdate();
    FTextGameForm.RadioResponses.Items.Clear();
    FTextGameForm.RadioResponses.Items.Add('A - Il n''y pas de Réponse');
    FTextGameForm.RadioResponses.Items.Add('B - 42');
    FTextGameForm.RadioResponses.Items.Add('C - Le Restaurant de la Fin du Monde');
    FTextGameForm.RadioResponses.Items.Add('D - La Réponse D');
    FTextGameForm.RadioResponses.Items.EndUpdate();
    FTextGameForm.BtnOK.OnClick := StepReponse2;
  end;
end;
 
procedure TTextGameEngine.StepReponse2(Sender: TObject);
begin
  if CheckStep(2) then
  begin
    case FTextGameForm.RadioResponses.ItemIndex of
      0: Stop;
      1: Stop;
      2: Stop;
      3: Stop
      else
        Step2();
    end;
  end;
end;
 
 
procedure TTextGameEngine.Step3;
begin
  Stop
end;
 
procedure TTextGameEngine.Step4;
begin
  Stop
end;
 
procedure TTextGameEngine.Step5;
begin
  Stop
end;
 
end.

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
 
unit Frm_TextGame;
 
interface
 
uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, ExtCtrls;
 
type
  TTextGameForm = class(TForm)
    MemoQuestion: TMemo;
    RadioResponses: TRadioGroup;
    BtnOK: TButton;
  private
    { Déclarations privées }
  public
    { Déclarations publiques }
  end;
 
var
  TextGameForm: TTextGameForm;
 
implementation
 
{$R *.dfm}
 
end.