Idées pour un damier sous Turbo Vision

**Roland Chastain** · 03/05/2012, 17h57

Une discussion autour de Turbo Vision trouvera-t-elle des amateurs ?

Je m'y suis plongé depuis quelques jours, dans l'intention d'apprendre les bases de la programmation événementielle. Outre l'intérêt théorique de la chose, c'est vraiment un bel outil, qui reste parfaitement utilisable.

Je cherche donc de quel type d'objet je pourrais me servir pour faire un damier. Auriez-vous des idées à me donner ?

J'ai déjà trouvé le début :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
program Exemple;
 
{ --- Le plus petit code Turbo Vision --- }
 
uses App;
 
var a: TApplication;
 
begin
  a.Init;
  a.Run;
  a.Done;
end.

**droggo** · 03/05/2012, 18h40

Joa,

Désolé, il y a bien trop longtemps que je n'utilise plus ce bel outil (en gros, depuis la sortie de BPW, ce qui ne nous rajeunit pas

).

**Paul TOTH** · 03/05/2012, 18h52

pareil, c'est trop vieux pour que je me souvienne des détails...par contre je me souviens d'une écriture assez lourde avec les pointeurs d'objets qui ont été agréablement remplacés par des classes d'objet dans Delphi.

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
 
var
  TMonObject = object
    constructor Init;
  end;
  PMonObject = ^TMonObject;
 
var
  o1 : PMonObject;
begin
  New(o1, Init);
end;
 
// et sous Delphi
 
tyoe
  TMaClass = class
    constructor Create;
  end;
 
var
  c1: TMaClass;
begin
  c1 := TMaClass.Create;
end;

**M.Dlb** · 03/05/2012, 19h07

Ahhhh un amateur de Turbo Vision... Pour ce genre d'affichage, je verrais 2 possibilités:

Soit une surcharge de TDesktop, où tu dessinerai directement ton damier et tes pièces.
Soit une fenêtre "custom" où tu affiches le damier et les pièces aussi...

Il faut savoir que Turbo Vision, c'est un mode "multi fenêtres", donc ca peut influencer la façon dont tu disposes ton écran, car une fenetre peut en recouvrir une autre etc...

Tu peux regarder ces deux tutos:
http://mdalbin.developpez.com/tutori...l/turbovision/
http://mdalbin.developpez.com/tutoriels/pascal/tvpa/

Turbo Vision est vraiment marrant à programmer, surtout quand tu commences à faire tes propres composants...

**Roland Chastain** · 03/05/2012, 20h33

Envoyé par wormful_sickfoot

Pour ce genre d'affichage, je verrais 2 possibilités:

Soit une surcharge de TDesktop, où tu dessinerai directement ton damier et tes pièces.
Soit une fenêtre "custom" où tu affiches le damier et les pièces aussi...

D'accord, je vais regarder de ce côté-là.

Envoyé par wormful_sickfoot

Il faut savoir que Turbo Vision, c'est un mode "multi fenêtres", donc ca peut influencer la façon dont tu disposes ton écran, car une fenetre peut en recouvrir une autre etc...

Comme je débute, je pense que je vais partir sur le projet le plus simple possible.

Envoyé par wormful_sickfoot

Tu peux regarder ces deux tutos:
http://mdalbin.developpez.com/tutori...l/turbovision/
http://mdalbin.developpez.com/tutoriels/pascal/tvpa/

Je les ai lus et relus. J'ai même écrit mon premier bout de code (pièce jointe) à partir de l'exemple donné dans la première partie.

J'ai juste changé des valeurs pour voir si je comprenais le code. Puis j'ai ajouté le mode 43 lignes en noir et blanc. Dans 25 lignes mon échiquier est trop à l'étroit. Mais 43 lignes n'entrent pas dans mon écran ! C'est pourquoi j'étais très content de trouver hier une unité qui permet un mode de 28 lignes. Juste ce qu'il me faut !

Je retourne au travail.

**M.Dlb** · 03/05/2012, 20h38

Envoyé par Roland Chastain

Mais 43 lignes n'entrent pas dans mon écran !

Tu dois certainement ajuster ton écran pour que ca rentre. Si c'est un écran plat, tu as une option pour auto-ajuster l'affichage à la configuration utilisée.

**Alcatîz** · 03/05/2012, 21h45

Bonjour,

Pour ton information, Turbo Vision existe également sous Free Pascal et Virtual Pascal.

**Roland Chastain** · 03/05/2012, 22h11

Envoyé par wormful_sickfoot

Tu dois certainement ajuster ton écran pour que ca rentre. Si c'est un écran plat, tu as une option pour auto-ajuster l'affichage à la configuration utilisée.

Merci du conseil. Je vais essayer pour voir ce que ça donne.

J'avais oublié la pièce jointe dans mon précédent message, je l'ai rajoutée. Voici une capture d'écran. C'est joli, non ?

**M.Dlb** · 03/05/2012, 22h13

La version adapté de Turbo Vision pour Free Pascal s'appelle Free Vision. FV fonctionne à 99% pareil que Turbo Pascal, les applis développées avec Turbo Vision sont directement portable sous FV, quelques problèmes subsistent si quelques fonctions sont appelées car leur équivalent FV n'existent pas forcément. Dans ce cas, il faut légèrement modifier le code...

**Roland Chastain** · 03/05/2012, 23h20

Envoyé par Alcatîz

Pour ton information, Turbo Vision existe également sous Free Pascal et Virtual Pascal.

Bon à savoir !

Je viens de faire l'essai avec l'un et l'autre : impeccable.

En revanche je n'ai pas réussi à mettre la main sur un manuel. Quelqu'un n'en aurait-il pas une copie dans un coin de son disque dur ?

**M.Dlb** · 03/05/2012, 23h43

F1

L'aide de TP est complète, quelle soit en anglais ou en français.

**Roland Chastain** · 06/05/2012, 19h54

Envoyé par wormful_sickfoot

F1

L'aide de TP est complète, quelle soit en anglais ou en français.

Cela m'avait échappé.

Je n'avais pas remarqué non plus que le dossier DOCDEMOS contenait un tutoriel Turbo Vision.

J'ai passé du temps à lire des exemples de code et je commence à voir à peu près comment les choses fonctionnent, mais je n'ai pas vraiment avancé en ce qui concerne mon damier.

Voici ce que j'ai fait :

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
(* Recherche d'un damier sous Turbo Vision *)
 
Program Essai1;
 
Uses
  App,
  Drivers,
  Objects;
 
Type
  Ta=Object(TApplication)
    Procedure InitDesktop; Virtual;
    Constructor Init;
  End;
 
Var
  a: Ta;
 
Constructor Ta.Init;
Begin
  Inherited Init;
  SetScreenMode(smBW80);
  Redraw;
End;
 
Procedure Ta.InitDesktop;
Var r: TRect;
Begin
  r.Assign(0,0,24,16);
  Desktop:=New(PDesktop,Init(r));
End;
 
Begin
  a.Init;
  a.Run;
  a.Done;
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
(* Recherche d'un damier sous Turbo Vision *)
 
Program Essai2;
 
Uses
  App,
  Objects;
 
Type
  Pd=^Td;
  Td=Object(TDesktop)
    Procedure InitBackground; Virtual;
  End;
 
  Ta=Object(TApplication)
    Procedure InitDesktop; Virtual;
  End;
 
Procedure Td.InitBackground;
Var r: TRect;
Begin
  GetExtent(r);
  New(Background,Init(r,'X'));
End;
 
Procedure Ta.InitDesktop;
Var r: TRect;
Begin
  r.Assign(0,0,24,16);
  DeskTop:=New(Pd,Init(r));
End;
 
Var a: Ta;
Begin
  a.Init;
  a.Run;
  a.Done;
End.

A l'aide !

**M.Dlb** · 07/05/2012, 12h26

Hello,

En y réflechissant, tu ne pourras pas gérer les évènements avec un le TDesktop. Le mieux pour toi serait de définir un composant spécifique, que tu peux appeler TDamier par exemple, héritant de TView qui permet de gérer les évènements (en surchargeant la méthode HandleEvent)...

**M.Dlb** · 07/05/2012, 14h43

Début de réponse:

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
{$G+}
 
uses Dos, App, Objects, Views, Drivers, Dialogs, MsgBox, Validate, Menus, StdDlg;
 
type PDamier = ^TDamier;
     TDamier = object(TView)
     public
       constructor Init(var Bounds: TRect);
       procedure Draw; virtual;
       function GetPalette: PPalette; virtual;
       destructor Done; virtual;
     end;
 
type TMyApp = object(TApplication)
     private
       Damier: PDamier;
     public
       constructor Init;
       procedure InitMenuBar; virtual;
       procedure InitStatusLine; virtual;
       procedure InitDesktop; virtual;
       function GetPalette: PPalette; virtual;
       destructor Done; virtual;
     end;
 
const CAppPalette = #$78#$70#$78#$74#$20#$74#$78#$73#$7F#$7A +
                    #$31#$31#$1E#$71#$00#$2F#$3F#$3A#$13#$13 +
                    #$3E#$21#$00#$70#$7F#$13#$78#$74#$70#$7F +
                    #$00#$70#$7F#$7A#$13#$13#$70#$70#$7F#$7E +
                    #$20#$2B#$2F#$78#$2E#$70#$30#$3F#$3E#$1F +
                    #$2F#$1A#$20#$72#$31#$31#$30#$2F#$3E#$31 +
                    #$13#$00#$00#$07#$70;
const CDamier = CBackGround + #64#65;
 
var MyApp: TMyApp;
 
constructor TDamier.Init(var Bounds: TRect);
begin
  if not inherited Init(Bounds) then Fail;
end;
 
procedure TDamier.Draw;
var X, Y, I: Integer;
begin
  inherited Draw;
  for Y := 0 to 8 do
    for X := 0 to 8 do
    begin
      for I := 0 to 4 do
      begin
        if (odd(X) xor odd(Y) = true) then
          WriteChar(X * 5, Y * 5 + I, ' ', 2, 5)
        else
          WriteChar(X * 5, Y * 5 + I, ' ', 3, 5);
      end;
      if (odd(X) xor odd(Y) = true) then
        WriteChar(X * 5 + 2, Y * 5 + 2, '*', 2, 1)
      else
        WriteChar(X * 5 + 2, Y * 5 + 2, '*', 3, 1);
    end;
end;
 
function TDamier.GetPalette: PPalette;
const P: String[Length(CAppPalette)] = CDamier;
begin
  GetPalette := @P;
end;
 
destructor TDamier.Done;
begin
  inherited Done;
end;
 
(****************************************************************************)
(***                *********************************************************)
(***  TMyApp  *********************************************************)
(***                *********************************************************)
(****************************************************************************)
 
constructor TMyApp.Init;
var Bounds: TRect;
    I: Integer;
begin
  if not inherited Init then Fail;
  SetScreenMode(smCO80 + smFont8x8);
  Redraw;
  Bounds.Assign(20, 4, 60, 44);
  Damier := New(PDamier, Init(Bounds));
  Desktop^.Insert(Damier);
end;
 
procedure TMyApp.InitMenuBar;
begin
  MenuBar := Nil;
end;
 
procedure TMyApp.InitStatusLine;
var Bounds: TRect;
begin
  Bounds.Assign(0, 49, 80 ,50);
  StatusLine := New(PStatusLine, Init(Bounds, NewStatusDef(0, 0,
	        NewStatusKey('~Alt+X~ Exit', kbAltX, cmQuit, Nil), Nil)));
 
end;
 
procedure TMyApp.InitDesktop;
var Bounds: TRect;
begin
  Bounds.Assign(0, 0, 80, 49);
  Desktop := New(PDesktop, Init(Bounds));
end;
 
function TMyApp.GetPalette: PPalette;
const P: String[Length(CAppPalette)] = CAppPalette;
begin
  GetPalette := @P;
end;
 
destructor TMyApp.Done;
begin
  inherited Done;
end;
 
(****************************************************************************)
(***        *****************************************************************)
(***  Main  *****************************************************************)
(***        *****************************************************************)
(****************************************************************************)
 
begin
  MyApp.Init;
  MyApp.Run;
  MyApp.Done;
end.

**Roland Chastain** · 07/05/2012, 15h11

Merci pour ta réponse.

Envoyé par wormful_sickfoot

En y réflechissant, tu ne pourras pas gérer les évènements avec un TDesktop.

C'est ce qui me semblait aussi. Mais je suis quand même content d'avoir appris (grâce à un exemple trouvé dans ton tutoriel

) comment on peut modifier le bureau : ça me servira de toute façon.

Envoyé par wormful_sickfoot

Le mieux pour toi serait de définir un composant spécifique, que tu peux appeler TDamier par exemple, héritant de TView qui permet de gérer les évènements (en surchargeant la méthode HandleEvent)...

Je vais explorer cette piste. J'étais en train de travailler sur un exemple qui utilise le type TWindow, qui "descend" si j'ai bien compris du type TView. J'espère poster quelque chose d'ici ce soir.

[EDIT]
Merci pour ton exemple, que je viens de voir. Je vais prendre le temps de l'étudier.

**Roland Chastain** · 09/05/2012, 02h21

Envoyé par wormful_sickfoot

Début de réponse:

J'ai compris pas mal de choses en étudiant ton exemple de code.

Voici ce que j'ai fait:

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
Program Essai3; (* Recherche d'un damier sous Turbo Vision *)
 
Uses
  App,     (* TApplication *)
  Objects, (* TRect        *)
  Views,   (* TView        *)
  Drivers; (* smCO80       *)
 
Type
  PDamier=^TDamier;
 
  TDamier=Object(TView)
    Constructor Init(Var r: TRect);
    Procedure Draw; Virtual;
    Destructor Done; Virtual;
  End;
 
  TJeu=Object(TApplication)
    Private
    Damier: PDamier;
    Public
    Constructor Init;
    Procedure InitMenuBar; Virtual;
    Procedure InitDesktop; Virtual;
    Destructor Done; Virtual;
  End;
 
 
Var
  Jeu: TJeu;
 
Constructor TDamier.Init(Var r: TRect);
Begin
  If Not Inherited Init(r) Then Fail;
End;
 
Procedure TDamier.Draw;
Var
  x,y: Byte;
  couleur: Byte;
  i: Byte;
Begin
  Inherited Draw;
  For y:=7 DownTo 0 Do
    For x:=0 To 7 Do
      Begin
        If Odd(x+y)
        Then
          couleur:=6
        Else
          couleur:=1;
 
        For i:=0 to 1 Do
          WriteChar(3 + 3*x, 2 + 14 - 2*y + i, #219, couleur, 3);
 
      End;
End;
 
Destructor TDamier.Done;
Begin
  Inherited Done;
End;
 
Constructor TJeu.Init;
Var r: TRect;
Begin
  If Not Inherited Init Then Fail;
  SetScreenMode(smCO80);
  Redraw;
  r.Assign(3,2,3+30,2+20);
  Damier:=New(PDamier,Init(r));
  Desktop^.Insert(Damier);
End;
 
Procedure TJeu.InitMenuBar;
Begin
  MenuBar:=Nil;
End;
 
Procedure TJeu.InitDesktop;
Var r: TRect;
Begin
  r.Assign(0,0,80,24);
  Desktop:=New(PDesktop,Init(r));
End;
 
Destructor TJeu.Done;
Begin
  Inherited Done;
End;
 
Begin
  Jeu.Init;
  Jeu.Run;
  Jeu.Done;
End.