0:00:01.532,0:00:03.479
Continuons.

0:00:03.744,0:00:05.683
La prochaine étape est

0:00:05.683,0:00:07.824
d'écrire notre classe [br]pour le script «AnswerData»

0:00:08.803,0:00:12.024
elle y contiendra les données[br]de toutes nos réponses.

0:00:12.526,0:00:15.021
Double-cliquez,[br]le script s'ouvre.

0:00:15.782,0:00:20.336
Et pour ce script j'utiliserez[br]"MonoDevelop".

0:00:20.569,0:00:22.120
Puis je cite mes notes ici

0:00:22.441,0:00:25.109
Maximisons l'espace de la fenêtre...

0:00:25.295,0:00:26.415
Nous verrons mieux à l'écran

0:00:26.630,0:00:27.379
Ok.

0:00:27.573,0:00:28.053
Donc,

0:00:28.251,0:00:30.022
Nous allons créer une série

0:00:30.125,0:00:32.110
de petites classes[br]qui ne sont pas de type [br]«MonoBehaviour»

0:00:32.610,0:00:35.477
Il s'agira de pures[br]classes c#

0:00:35.630,0:00:39.647
Et elles utiliseront:[br]"[System.Serializable]"

0:00:39.917,0:00:40.982
En fait,

0:00:41.164,0:00:41.979
La raison pour laquelle nous

0:00:42.219,0:00:42.791
utilisons ceci,

0:00:42.955,0:00:44.581
est pour que nous puissions[br]les modifier

0:00:44.818,0:00:46.250
et détruire leurs valeurs

0:00:46.426,0:00:47.426
en utilisant "l'inspector"

0:00:47.554,0:00:48.792
dans l'éditeur «Unity».[br]("Unity Editor")

0:00:48.931,0:00:50.714
Alors, elles n'utiliseront pas

0:00:50.862,0:00:51.810
de fonctions

0:00:51.928,0:00:53.997
Nous allons donc supprimer[br]"Start" et "Update puis

0:00:54.302,0:00:56.900
cette classe contiendra uniquement[br]que deux variables.

0:00:57.048,0:00:59.594
D'abord, nous aurons besoin[br]d'un "Public string"

0:00:59.746,0:01:01.125
que nous nommerons:[br]«answerText»

0:01:01.295,0:01:04.751
Ce sera le "string" qui contiendra[br]le texte de notre réponse.

0:01:04.932,0:01:08.575
Qu'il s'agisse de:[br]Oui, Non, Vrai, Faux, etc

0:01:08.741,0:01:12.052
Ensuite nous écrirons un[br]"public boolean"

0:01:12.182,0:01:13.837
que nous appelons:[br]"isCorrect".

0:01:13.931,0:01:16.034
Et ceci contiendra[br]l'information de la réponse

0:01:16.172,0:01:19.770
si elle est réponse est bonne ou non[br]ainsi que la question elle-même.

0:01:19.884,0:01:23.010
C'est tout ce dont nous aurons

0:01:23.080,0:01:23.930
besoin pour cette classe,

0:01:24.200,0:01:25.930
donc fermons cette dernière.

0:01:26.073,0:01:27.166
Retournons à «Unity»

0:01:27.366,0:01:28.397
Et nous allons créer notre

0:01:28.449,0:01:29.210
prochaine classe

0:01:29.240,0:01:30.158
qui sera

0:01:30.314,0:01:32.313
note classe nommée:[br]«QuestionData».

0:01:32.590,0:01:36.029
Allons créer un nouveau[br]C# Script et nommons-le

0:01:36.779,0:01:37.810
«QuestionData»

0:01:39.281,0:01:40.536
Ce script servira d'éditeur

0:01:40.819,0:01:43.893
Encore une fois,[br]Ce ne sera pas de type «MonoBehaviour»

0:01:44.073,0:01:46.040
Nous n'utiliserons donc pas[br]«Start» ni «Update».

0:01:46.242,0:01:48.615
Mais nous utiliserons:

0:01:48.820,0:01:52.816
"[System.Serializable]"

0:01:53.129,0:01:54.424
Dans «QuestionData»,

0:01:54.690,0:01:56.485
nous aurons besoin d'un[br]"public string"

0:01:56.689,0:01:58.528
pour notre "questionText"[br](le texte de notre queston)

0:01:58.754,0:02:01.922
et nous utiliserons un[br]"public array"

0:02:02.140,0:02:04.017
contenant notre «AnswerData»

0:02:04.226,0:02:05.407
appelé: «answers».

0:02:05.567,0:02:06.526
Donc, chaque question

0:02:06.718,0:02:08.644
contiendra un nombre de réponses

0:02:08.979,0:02:11.874
que nous associerons a celles-ci,

0:02:11.874,0:02:15.561
elles seront gardées dans nos classes: «AnswerData»[br]que nous venons tout juste de créer.

0:02:15.561,0:02:19.310
Et chaque tour ("Round")

0:02:19.310,0:02:20.884
contiendra une série de questions.

0:02:20.884,0:02:24.028
Donc, la prochaine "classe"[br]que nous allons créer

0:02:24.028,0:02:26.044
Retournons à «Unity»

0:02:26.044,0:02:27.975
Créer un script C#

0:02:27.975,0:02:28.653
Celui-ci sera nommé:

0:02:28.653,0:02:31.966
«RoundData».

0:02:31.966,0:02:34.550
Et tel que «QuestionData» et «AnswerData»,

0:02:34.550,0:02:41.523
ce script sera lui aussi "Serializable"

0:02:41.523,0:02:43.319
Ne sera pas non plus[br]de type «MonoBehaviour»

0:02:43.319,0:02:46.167
Donc n'utilisera pas les fonctions[br]«Start» et «Update»,

0:02:46.167,0:02:49.367
et celui-ci contiendra quatre variables.

0:02:49.367,0:02:51.747
Le premier est un "string"[br]que nous nommons:

0:02:51.747,0:02:54.570
«name», pour le nom de notre "Round",

0:02:54.570,0:02:58.219
Le second sera un "integer",[br]que nous appelons:

0:02:58.219,0:02:59.653
«timeLimitInSeconds»

0:02:59.653,0:03:04.892
Donc, combien de secondes données[br]aura le joueur pour terminer ce "Round";

0:03:04.892,0:03:07.459
Le troisième sera un "public int"

0:03:07.459,0:03:13.879
appelé: "pointsAddedForCorrectAnswers"[br](points gagnés pour bonnes réponses)

0:03:13.879,0:03:18.589
Ceci servira à calculer combien de points[br]vous obtiendrai par bonnes réponses.

0:03:18.589,0:03:19.593
Finallement,

0:03:19.593,0:03:21.042
Nous aurons besoin d'un autre

0:03:21.042,0:03:24.172
"public «Array» de type "QuestionData"[br]("public QuestionData[] question;")

0:03:24.172,0:03:25.508
appelé: «questions».

0:03:25.508,0:03:29.661
Donc, chaque "Round" contiendra un certain[br]nombre de questions,

0:03:29.661,0:03:32.386
puis chaque question contiendra un certain[br]nombre de réponses.

0:03:32.386,0:03:36.480
en utilisant ces variables[br]de type «public "arrays" [ ] »

0:03:36.480,0:03:38.563
Enregistrons le tout.

0:03:38.563,0:03:41.516
Puis maintenant,

0:03:41.516,0:03:48.059
Nous pouvons revenir et remplir notre[br]classe «DataController» qui devra gérer

0:03:48.059,0:03:49.717
toutes ces données.

0:03:49.717,0:03:52.401
Alors, ouvrons ce dernier..

0:03:52.401,0:03:53.539
Et celui-ci, cette fois

0:03:53.539,0:03:54.899
s'agira d'un script de type "MonoBehaviour"

0:03:54.899,0:03:56.510
puisqu'il est attaché à notre

0:03:56.510,0:04:04.584
"DataController GameObject" et celui-ci[br]devra utiliser

0:04:05.284,0:04:07.968
"UnityEngine.SceneManagement".

0:04:08.109,0:04:10.823
C'est pourquoi nous devons écrire[br]Ici-haut dans le script:

0:04:11.073,0:04:12.904
« using UnityEngine.SceneManagement; »

0:04:13.074,0:04:16.161
pour qu'ainsi, nous puissions[br]charger nos scènes dans notre jeu.

0:04:16.966,0:04:21.901
Par la suite,[br]Nous ajouterons

0:04:21.901,0:04:26.764
un "public «Array» ( [ ] )[br]de type "RoundData", [br]

0:04:27.167,0:04:31.093
que nous nommons:[br]" public RoundData [ ] allRoundData; "

0:04:31.461,0:04:33.187
Donc, un peu plus tard,

0:04:33.187,0:04:35.165
nous pourrons rallonger le jeu[br]Et y insérer plusieurs autres «Round»,

0:04:35.165,0:04:37.720
Mais pour l'instant nous n'en aurons[br]qu'un seul et unique.

0:04:37.720,0:04:40.121
Mais nous l'inscrirons ici avec un «array» [ ]

0:04:40.121,0:04:43.483
pour que nous puissions le rallonger[br]un peu plus tard dans cette session.

0:04:43.483,0:04:48.902
Ensuite, nous allons[br]configurer ce "GameObject"

0:04:48.902,0:04:50.163
pour qu'il ne se détruise pas[br]au chargement de notre jeu.

0:04:50.163,0:04:51.295
(DontDestroyOnLoad)

0:04:51.295,0:04:53.490
Nous allons donc faire appel[br]a la fonction "DontDestroyOnLoad"

0:04:53.490,0:04:55.825
Et poursuivre vers le "GameObject"

0:04:55.825,0:04:57.198
dont le script y est attaché.

0:04:57.198,0:04:58.809
Ce dont cela signifie,

0:04:58.809,0:05:00.843
est que normalement lorsque nous[br]chargeons une nouvelle scène,[br]

0:05:00.843,0:05:03.217
chaque objet dans les scènes précédentes

0:05:03.217,0:05:05.454
qui ne sont plus activées, sont détruites.

0:05:05.454,0:05:08.786
En configurant cet objet avec[br]«DontDestroyOnLoad»

0:05:08.786,0:05:11.649
lorsque nous ouvrons une nouvelle scène,[br]rien ne se détruit dans la scène.

0:05:11.649,0:05:13.951
La façon de le voir par l'interface de Unity,

0:05:13.951,0:05:17.418
c'est en observant le seul objet qui [br]se divise dans le jeu et qui reviendra

0:05:17.418,0:05:20.677
chaque fois sous le nom de:[br]«DontDestroyOnLoad» ;

0:05:20.937,0:05:25.201
Alors, dans notre cas,[br]Configurons ceci avec «DontDestroyOnLoad»

0:05:25.321,0:05:27.202
Et ensuite nous allons écrire:

0:05:27.368,0:05:31.193
SceneManagement.LoadScene

0:05:31.448,0:05:36.487
puis nous allons charger le MenuScreen.

0:05:36.487,0:05:38.241
Maintenant,

0:05:38.251,0:05:40.275
La raison principale de ce script «DataController»,

0:05:40.275,0:05:45.951
est d'alimenter «RoundData» à notre «GameController»[br]Lorsque nous arriverons à cette scène

0:05:45.951,0:05:51.321
Nous allons donc déclarer une fonction «public»[br]Pour retourner un objet de type «RoundData»

0:05:51.321,0:05:58.462
que nous nommons: «GetCurrentRoundData».

0:05:58.462,0:06:05.810
Et dans ce cas nous allons écrire:[br]«return allRoundData [0]»

0:06:05.810,0:06:09.864
Dans ce cas nous savons que nous aurons[br]qu'uniquement «data» à notre roundData "0"

0:06:09.864,0:06:12.521
dans notre RoundData "0"

0:06:12.521,0:06:19.075
Mais si nous voulons élargir le tout[br]un peu plus tard, nous pourrions

0:06:19.235,0:06:23.017
créer un «int», pour spécifier[br]quelle donnée nous voulons retourner, etc.

0:06:23.017,0:06:23.949
Ok.

0:06:23.959,0:06:29.802
C'est tous ce que nous aurons[br]besoin pour l'instant, enregistrons le tout.

0:06:30.133,0:06:31.463
Retournons à Unity.

0:06:31.726,0:06:33.381
Et maintenant,

0:06:33.528,0:06:37.611
Avant de pouvoir charger une des scènes[br]que nous venons de créer,

0:06:37.770,0:06:39.365
Nous avons besoin de les ajouter[br]dans notre «Build Settings»

0:06:39.515,0:06:42.607
Donc, allons à «File» et «Build Settings»

0:06:42.741,0:06:45.232
Glissons d'abord notre scène[br]nommée: «Persistent»

0:06:45.378,0:06:49.121
Notre scène nommée «Persistent»,[br]sera celle qui sera chargée au départ

0:06:49.121,0:06:51.251
lorsque nous démarrerons notre application

0:06:51.251,0:06:57.579
et nous mènera directement[br]à notre scène «MenuScreen».

0:06:57.579,0:07:00.067
Lorsque le joueur joueras plusieurs[br]"Round" de notre jeu,

0:07:00.067,0:07:02.647
Il sera toujours automatiquement retourné[br]à notre scène «MenuScreen»

0:07:02.647,0:07:05.359
La scène «Persistent» sera toujours chargée

0:07:05.359,0:07:08.104
la première fois, lorsque le jeu démarrera,

0:07:08.104,0:07:21.487
Ensuite notre DataController gardera[br]la donnée en mémoire et ne sera pas détruite

0:07:21.487,0:07:23.203
Donc,

0:07:23.270,0:07:25.288
Nous allons ajouter la scène «Persistent»,

0:07:25.288,0:07:26.674
Ensuite, la scène «MenuScreen»

0:07:26.674,0:07:29.415
Et enfin, la scène «Game».

0:07:29.415,0:07:30.468
Ok.

0:07:30.468,0:07:32.257
Donc, maintenant elles sont disponibles

0:07:32.257,0:07:33.487
Les scènes peuvent être chargées.

0:07:33.487,0:07:36.676
Et on peut

0:07:36.676,0:07:39.424
Enregistrer notre «DataController»

0:07:39.424,0:07:41.455
Jouer.

0:07:41.455,0:07:46.380
Et

0:07:46.580,0:07:49.557
Ok, ça fonctionne.

0:07:49.980,0:07:51.543
Elles sont trop pareilles

0:07:51.543,0:07:54.713
Mettons l'arrière-plan de la[br]«Main Camera» noir

0:07:54.713,0:07:56.119
dans la scène «Menu Screen»[br]pour que vous puissiez voir

0:07:56.215,0:07:59.075
comme il faut ce qui se passe[br]dans la scène.

0:07:59.227,0:08:00.071
Donc voilà, on commence ici,

0:08:00.101,0:08:01.000
Il n'y a aucune caméra[br]et ça nous amène à

0:08:01.006,0:08:02.421
une scène noire,[br]n'est-ce pas?

0:08:02.474,0:08:04.614
Donc,[br]Ça fonctionne tel que prévu.

0:08:04.614,0:08:05.822
Immédiatement,

0:08:05.822,0:08:07.902
la scène «MenuScreen» démarre

0:08:07.902,0:08:13.278
Et maintenant, notre «DataController»[br]enclenche cette scène «DontDestroyOnLoad»

0:08:13.598,0:08:15.711
Dont laquelle elle ne sera pas détruite.

0:08:15.885,0:08:18.132
Alors, tout fonctionne tel que prévu.

0:08:18.384,0:08:20.419
Donc, je vais jeter un coup d’œil[br]rapide sur la "chat",

0:08:20.419,0:08:25.343
Et voyons voir,[br]si tout le monde se porte bien.