1
00:00:01,532 --> 00:00:03,479
Continuons.

2
00:00:03,744 --> 00:00:05,683
La prochaine étape est

3
00:00:05,683 --> 00:00:07,824
d'écrire notre classe 
pour le script «AnswerData»

4
00:00:08,803 --> 00:00:12,024
elle y contiendra les données
de toutes nos réponses.

5
00:00:12,526 --> 00:00:15,021
Double-cliquez,
le script s'ouvre.

6
00:00:15,782 --> 00:00:20,336
Et pour ce script j'utiliserez
"MonoDevelop".

7
00:00:20,569 --> 00:00:22,120
Puis je cite mes notes ici

8
00:00:22,441 --> 00:00:25,109
Maximisons l'espace de la fenêtre...

9
00:00:25,295 --> 00:00:26,415
Nous verrons mieux à l'écran

10
00:00:26,630 --> 00:00:27,379
Ok.

11
00:00:27,573 --> 00:00:28,053
Donc,

12
00:00:28,251 --> 00:00:30,022
Nous allons créer une série

13
00:00:30,125 --> 00:00:32,110
de petites classes
qui ne sont pas de type 
«MonoBehaviour»

14
00:00:32,610 --> 00:00:35,477
Il s'agira de pures
classes c#

15
00:00:35,630 --> 00:00:39,647
Et elles utiliseront:
"[System.Serializable]"

16
00:00:39,917 --> 00:00:40,982
En fait,

17
00:00:41,164 --> 00:00:41,979
La raison pour laquelle nous

18
00:00:42,219 --> 00:00:42,791
utilisons ceci,

19
00:00:42,955 --> 00:00:44,581
est pour que nous puissions
les modifier

20
00:00:44,818 --> 00:00:46,250
et détruire leurs valeurs

21
00:00:46,426 --> 00:00:47,426
en utilisant "l'inspector"

22
00:00:47,554 --> 00:00:48,792
dans l'éditeur «Unity».
("Unity Editor")

23
00:00:48,931 --> 00:00:50,714
Alors, elles n'utiliseront pas

24
00:00:50,862 --> 00:00:51,810
de fonctions

25
00:00:51,928 --> 00:00:53,997
Nous allons donc supprimer
"Start" et "Update puis

26
00:00:54,302 --> 00:00:56,900
cette classe contiendra uniquement
que deux variables.

27
00:00:57,048 --> 00:00:59,594
D'abord, nous aurons besoin
d'un "Public string"

28
00:00:59,746 --> 00:01:01,125
que nous nommerons:
«answerText»

29
00:01:01,295 --> 00:01:04,751
Ce sera le "string" qui contiendra
le texte de notre réponse.

30
00:01:04,932 --> 00:01:08,575
Qu'il s'agisse de:
Oui, Non, Vrai, Faux, etc

31
00:01:08,741 --> 00:01:12,052
Ensuite nous écrirons un
"public boolean"

32
00:01:12,182 --> 00:01:13,837
que nous appelons:
"isCorrect".

33
00:01:13,931 --> 00:01:16,034
Et ceci contiendra
l'information de la réponse

34
00:01:16,172 --> 00:01:19,770
si elle est réponse est bonne ou non
ainsi que la question elle-même.

35
00:01:19,884 --> 00:01:23,010
C'est tout ce dont nous aurons

36
00:01:23,080 --> 00:01:23,930
besoin pour cette classe,

37
00:01:24,200 --> 00:01:25,930
donc fermons cette dernière.

38
00:01:26,073 --> 00:01:27,166
Retournons à «Unity»

39
00:01:27,366 --> 00:01:28,397
Et nous allons créer notre

40
00:01:28,449 --> 00:01:29,210
prochaine classe

41
00:01:29,240 --> 00:01:30,158
qui sera

42
00:01:30,314 --> 00:01:32,313
note classe nommée:
«QuestionData».

43
00:01:32,590 --> 00:01:36,029
Allons créer un nouveau
C# Script et nommons-le

44
00:01:36,779 --> 00:01:37,810
«QuestionData»

45
00:01:39,281 --> 00:01:40,536
Ce script servira d'éditeur

46
00:01:40,819 --> 00:01:43,893
Encore une fois,
Ce ne sera pas de type «MonoBehaviour»

47
00:01:44,073 --> 00:01:46,040
Nous n'utiliserons donc pas
«Start» ni «Update».

48
00:01:46,242 --> 00:01:48,615
Mais nous utiliserons:

49
00:01:48,820 --> 00:01:52,816
"[System.Serializable]"

50
00:01:53,129 --> 00:01:54,424
Dans «QuestionData»,

51
00:01:54,690 --> 00:01:56,485
nous aurons besoin d'un
"public string"

52
00:01:56,689 --> 00:01:58,528
pour notre "questionText"
(le texte de notre queston)

53
00:01:58,754 --> 00:02:01,922
et nous utiliserons un
"public array"

54
00:02:02,140 --> 00:02:04,017
contenant notre «AnswerData»

55
00:02:04,226 --> 00:02:05,407
appelé: «answers».

56
00:02:05,567 --> 00:02:06,526
Donc, chaque question

57
00:02:06,718 --> 00:02:08,644
contiendra un nombre de réponses

58
00:02:08,979 --> 00:02:11,874
que nous associerons a celles-ci,

59
00:02:11,874 --> 00:02:15,561
elles seront gardées dans nos classes: «AnswerData»
que nous venons tout juste de créer.

60
00:02:15,561 --> 00:02:19,310
Et chaque tour ("Round")

61
00:02:19,310 --> 00:02:20,884
contiendra une série de questions.

62
00:02:20,884 --> 00:02:24,028
Donc, la prochaine "classe"
que nous allons créer

63
00:02:24,028 --> 00:02:26,044
Retournons à «Unity»

64
00:02:26,044 --> 00:02:27,975
Créer un script C#

65
00:02:27,975 --> 00:02:28,653
Celui-ci sera nommé:

66
00:02:28,653 --> 00:02:31,966
«RoundData».

67
00:02:31,966 --> 00:02:34,550
Et tel que «QuestionData» et «AnswerData»,

68
00:02:34,550 --> 00:02:41,523
ce script sera lui aussi "Serializable"

69
00:02:41,523 --> 00:02:43,319
Ne sera pas non plus
de type «MonoBehaviour»

70
00:02:43,319 --> 00:02:46,167
Donc n'utilisera pas les fonctions
«Start» et «Update»,

71
00:02:46,167 --> 00:02:49,367
et celui-ci contiendra quatre variables.

72
00:02:49,367 --> 00:02:51,747
Le premier est un "string"
que nous nommons:

73
00:02:51,747 --> 00:02:54,570
«name», pour le nom de notre "Round",

74
00:02:54,570 --> 00:02:58,219
Le second sera un "integer",
que nous appelons:

75
00:02:58,219 --> 00:02:59,653
«timeLimitInSeconds»

76
00:02:59,653 --> 00:03:04,892
Donc, combien de secondes données
aura le joueur pour terminer ce "Round";

77
00:03:04,892 --> 00:03:07,459
Le troisième sera un "public int"

78
00:03:07,459 --> 00:03:13,879
appelé: "pointsAddedForCorrectAnswers"
(points gagnés pour bonnes réponses)

79
00:03:13,879 --> 00:03:18,589
Ceci servira à calculer combien de points
vous obtiendrai par bonnes réponses.

80
00:03:18,589 --> 00:03:19,593
Finallement,

81
00:03:19,593 --> 00:03:21,042
Nous aurons besoin d'un autre

82
00:03:21,042 --> 00:03:24,172
"public «Array» de type "QuestionData"
("public QuestionData[] question;")

83
00:03:24,172 --> 00:03:25,508
appelé: «questions».

84
00:03:25,508 --> 00:03:29,661
Donc, chaque "Round" contiendra un certain
nombre de questions,

85
00:03:29,661 --> 00:03:32,386
puis chaque question contiendra un certain
nombre de réponses.

86
00:03:32,386 --> 00:03:36,480
en utilisant ces variables
de type «public "arrays" [ ] »

87
00:03:36,480 --> 00:03:38,563
Enregistrons le tout.

88
00:03:38,563 --> 00:03:41,516
Puis maintenant,

89
00:03:41,516 --> 00:03:48,059
Nous pouvons revenir et remplir notre
classe «DataController» qui devra gérer

90
00:03:48,059 --> 00:03:49,717
toutes ces données.

91
00:03:49,717 --> 00:03:52,401
Alors, ouvrons ce dernier..

92
00:03:52,401 --> 00:03:53,539
Et celui-ci, cette fois

93
00:03:53,539 --> 00:03:54,899
s'agira d'un script de type "MonoBehaviour"

94
00:03:54,899 --> 00:03:56,510
puisqu'il est attaché à notre

95
00:03:56,510 --> 00:04:04,584
"DataController GameObject" et celui-ci
devra utiliser

96
00:04:05,284 --> 00:04:07,968
"UnityEngine.SceneManagement".

97
00:04:08,109 --> 00:04:10,823
C'est pourquoi nous devons écrire
Ici-haut dans le script:

98
00:04:11,073 --> 00:04:12,904
« using UnityEngine.SceneManagement; »

99
00:04:13,074 --> 00:04:16,161
pour qu'ainsi, nous puissions
charger nos scènes dans notre jeu.

100
00:04:16,966 --> 00:04:21,901
Par la suite,
Nous ajouterons

101
00:04:21,901 --> 00:04:26,764
un "public «Array» ( [ ] )
de type "RoundData", 


102
00:04:27,167 --> 00:04:31,093
que nous nommons:
" public RoundData [ ] allRoundData; "

103
00:04:31,461 --> 00:04:33,187
Donc, un peu plus tard,

104
00:04:33,187 --> 00:04:35,165
nous pourrons rallonger le jeu
Et y insérer plusieurs autres «Round»,

105
00:04:35,165 --> 00:04:37,720
Mais pour l'instant nous n'en aurons
qu'un seul et unique.

106
00:04:37,720 --> 00:04:40,121
Mais nous l'inscrirons ici avec un «array» [ ]

107
00:04:40,121 --> 00:04:43,483
pour que nous puissions le rallonger
un peu plus tard dans cette session.

108
00:04:43,483 --> 00:04:48,902
Ensuite, nous allons
configurer ce "GameObject"

109
00:04:48,902 --> 00:04:50,163
pour qu'il ne se détruise pas
au chargement de notre jeu.

110
00:04:50,163 --> 00:04:51,295
(DontDestroyOnLoad)

111
00:04:51,295 --> 00:04:53,490
Nous allons donc faire appel
a la fonction "DontDestroyOnLoad"

112
00:04:53,490 --> 00:04:55,825
Et poursuivre vers le "GameObject"

113
00:04:55,825 --> 00:04:57,198
dont le script y est attaché.

114
00:04:57,198 --> 00:04:58,809
Ce dont cela signifie,

115
00:04:58,809 --> 00:05:00,843
est que normalement lorsque nous
chargeons une nouvelle scène,


116
00:05:00,843 --> 00:05:03,217
chaque objet dans les scènes précédentes

117
00:05:03,217 --> 00:05:05,454
qui ne sont plus activées, sont détruites.

118
00:05:05,454 --> 00:05:08,786
En configurant cet objet avec
«DontDestroyOnLoad»

119
00:05:08,786 --> 00:05:11,649
lorsque nous ouvrons une nouvelle scène,
rien ne se détruit dans la scène.

120
00:05:11,649 --> 00:05:13,951
La façon de le voir par l'interface de Unity,

121
00:05:13,951 --> 00:05:17,418
c'est en observant le seul objet qui 
se divise dans le jeu et qui reviendra

122
00:05:17,418 --> 00:05:20,677
chaque fois sous le nom de:
«DontDestroyOnLoad» ;

123
00:05:20,937 --> 00:05:25,201
Alors, dans notre cas,
Configurons ceci avec «DontDestroyOnLoad»

124
00:05:25,321 --> 00:05:27,202
Et ensuite nous allons écrire:

125
00:05:27,368 --> 00:05:31,193
SceneManagement.LoadScene

126
00:05:31,448 --> 00:05:36,487
puis nous allons charger le MenuScreen.

127
00:05:36,487 --> 00:05:38,241
Maintenant,

128
00:05:38,251 --> 00:05:40,275
La raison principale de ce script «DataController»,

129
00:05:40,275 --> 00:05:45,951
est d'alimenter «RoundData» à notre «GameController»
Lorsque nous arriverons à cette scène

130
00:05:45,951 --> 00:05:51,321
Nous allons donc déclarer une fonction «public»
Pour retourner un objet de type «RoundData»

131
00:05:51,321 --> 00:05:58,462
que nous nommons: «GetCurrentRoundData».

132
00:05:58,462 --> 00:06:05,810
Et dans ce cas nous allons écrire:
«return allRoundData [0]»

133
00:06:05,810 --> 00:06:09,864
Dans ce cas nous savons que nous aurons
qu'uniquement «data» à notre roundData "0"

134
00:06:09,864 --> 00:06:12,521
dans notre RoundData "0"

135
00:06:12,521 --> 00:06:19,075
Mais si nous voulons élargir le tout
un peu plus tard, nous pourrions

136
00:06:19,235 --> 00:06:23,017
créer un «int», pour spécifier
quelle donnée nous voulons retourner, etc.

137
00:06:23,017 --> 00:06:23,949
Ok.

138
00:06:23,959 --> 00:06:29,802
C'est tous ce que nous aurons
besoin pour l'instant, enregistrons le tout.

139
00:06:30,133 --> 00:06:31,463
Retournons à Unity.

140
00:06:31,726 --> 00:06:33,381
Et maintenant,

141
00:06:33,528 --> 00:06:37,611
Avant de pouvoir charger une des scènes
que nous venons de créer,

142
00:06:37,770 --> 00:06:39,365
Nous avons besoin de les ajouter
dans notre «Build Settings»

143
00:06:39,515 --> 00:06:42,607
Donc, allons à «File» et «Build Settings»

144
00:06:42,741 --> 00:06:45,232
Glissons d'abord notre scène
nommée: «Persistent»

145
00:06:45,378 --> 00:06:49,121
Notre scène nommée «Persistent»,
sera celle qui sera chargée au départ

146
00:06:49,121 --> 00:06:51,251
lorsque nous démarrerons notre application

147
00:06:51,251 --> 00:06:57,579
et nous mènera directement
à notre scène «MenuScreen».

148
00:06:57,579 --> 00:07:00,067
Lorsque le joueur joueras plusieurs
"Round" de notre jeu,

149
00:07:00,067 --> 00:07:02,647
Il sera toujours automatiquement retourné
à notre scène «MenuScreen»

150
00:07:02,647 --> 00:07:05,359
La scène «Persistent» sera toujours chargée

151
00:07:05,359 --> 00:07:08,104
la première fois, lorsque le jeu démarrera,

152
00:07:08,104 --> 00:07:21,487
Ensuite notre DataController gardera
la donnée en mémoire et ne sera pas détruite

153
00:07:21,487 --> 00:07:23,203
Donc,

154
00:07:23,270 --> 00:07:25,288
Nous allons ajouter la scène «Persistent»,

155
00:07:25,288 --> 00:07:26,674
Ensuite, la scène «MenuScreen»

156
00:07:26,674 --> 00:07:29,415
Et enfin, la scène «Game».

157
00:07:29,415 --> 00:07:30,468
Ok.

158
00:07:30,468 --> 00:07:32,257
Donc, maintenant elles sont disponibles

159
00:07:32,257 --> 00:07:33,487
Les scènes peuvent être chargées.

160
00:07:33,487 --> 00:07:36,676
Et on peut

161
00:07:36,676 --> 00:07:39,424
Enregistrer notre «DataController»

162
00:07:39,424 --> 00:07:41,455
Jouer.

163
00:07:41,455 --> 00:07:46,380
Et

164
00:07:46,580 --> 00:07:49,557
Ok, ça fonctionne.

165
00:07:49,980 --> 00:07:51,543
Elles sont trop pareilles

166
00:07:51,543 --> 00:07:54,713
Mettons l'arrière-plan de la
«Main Camera» noir

167
00:07:54,713 --> 00:07:56,119
dans la scène «Menu Screen»
pour que vous puissiez voir

168
00:07:56,215 --> 00:07:59,075
comme il faut ce qui se passe
dans la scène.

169
00:07:59,227 --> 00:08:00,071
Donc voilà, on commence ici,

170
00:08:00,101 --> 00:08:01,000
Il n'y a aucune caméra
et ça nous amène à

171
00:08:01,006 --> 00:08:02,421
une scène noire,
n'est-ce pas?

172
00:08:02,474 --> 00:08:04,614
Donc,
Ça fonctionne tel que prévu.

173
00:08:04,614 --> 00:08:05,822
Immédiatement,

174
00:08:05,822 --> 00:08:07,902
la scène «MenuScreen» démarre

175
00:08:07,902 --> 00:08:13,278
Et maintenant, notre «DataController»
enclenche cette scène «DontDestroyOnLoad»

176
00:08:13,598 --> 00:08:15,711
Dont laquelle elle ne sera pas détruite.

177
00:08:15,885 --> 00:08:18,132
Alors, tout fonctionne tel que prévu.

178
00:08:18,384 --> 00:08:20,419
Donc, je vais jeter un coup d’œil
rapide sur la "chat",

179
00:08:20,419 --> 00:08:25,343
Et voyons voir,
si tout le monde se porte bien.