Continuons.
La prochaine étape est
d'écrire notre classe
pour le script «AnswerData»
elle y contiendra les données
de toutes nos réponses.
Double-cliquez,
le script s'ouvre.
Et pour ce script j'utiliserez
"MonoDevelop".
Puis je cite mes notes ici
Maximisons l'espace de la fenêtre...
Nous verrons mieux à l'écran
Ok.
Donc,
Nous allons créer une série
de petites classes
qui ne sont pas de type
«MonoBehaviour»
Il s'agira de pures
classes c#
Et elles utiliseront:
"[System.Serializable]"
En fait,
La raison pour laquelle nous
utilisons ceci,
est pour que nous puissions
les modifier
et détruire leurs valeurs
en utilisant "l'inspector"
dans l'éditeur «Unity».
("Unity Editor")
Alors, elles n'utiliseront pas
de fonctions
Nous allons donc supprimer
"Start" et "Update puis
cette classe contiendra uniquement
que deux variables.
D'abord, nous aurons besoin
d'un "Public string"
que nous nommerons:
«answerText»
Ce sera le "string" qui contiendra
le texte de notre réponse.
Qu'il s'agisse de:
Oui, Non, Vrai, Faux, etc
Ensuite nous écrirons un
"public boolean"
que nous appelons:
"isCorrect".
Et ceci contiendra
l'information de la réponse
si elle est réponse est bonne ou non
ainsi que la question elle-même.
C'est tout ce dont nous aurons
besoin pour cette classe,
donc fermons cette dernière.
Retournons à «Unity»
Et nous allons créer notre
prochaine classe
qui sera
note classe nommée:
«QuestionData».
Allons créer un nouveau
C# Script et nommons-le
«QuestionData»
Ce script servira d'éditeur
Encore une fois,
Ce ne sera pas de type «MonoBehaviour»
Nous n'utiliserons donc pas
«Start» ni «Update».
Mais nous utiliserons:
"[System.Serializable]"
Dans «QuestionData»,
nous aurons besoin d'un
"public string"
pour notre "questionText"
(le texte de notre queston)
et nous utiliserons un
"public array"
contenant notre «AnswerData»
appelé: «answers».
Donc, chaque question
contiendra un nombre de réponses
que nous associerons a celles-ci,
elles seront gardées dans nos classes: «AnswerData»
que nous venons tout juste de créer.
Et chaque tour ("Round")
contiendra une série de questions.
Donc, la prochaine "classe"
que nous allons créer
Retournons à «Unity»
Créer un script C#
Celui-ci sera nommé:
«RoundData».
Et tel que «QuestionData» et «AnswerData»,
ce script sera lui aussi "Serializable"
Ne sera pas non plus
de type «MonoBehaviour»
Donc n'utilisera pas les fonctions
«Start» et «Update»,
et celui-ci contiendra quatre variables.
Le premier est un "string"
que nous nommons:
«name», pour le nom de notre "Round",
Le second sera un "integer",
que nous appelons:
«timeLimitInSeconds»
Donc, combien de secondes données
aura le joueur pour terminer ce "Round";
Le troisième sera un "public int"
appelé: "pointsAddedForCorrectAnswers"
(points gagnés pour bonnes réponses)
Ceci servira à calculer combien de points
vous obtiendrai par bonnes réponses.
Finallement,
Nous aurons besoin d'un autre
"public «Array» de type "QuestionData"
("public QuestionData[] question;")
appelé: «questions».
Donc, chaque "Round" contiendra un certain
nombre de questions,
puis chaque question contiendra un certain
nombre de réponses.
en utilisant ces variables
de type «public "arrays" [ ] »
Enregistrons le tout.
Puis maintenant,
Nous pouvons revenir et remplir notre
classe «DataController» qui devra gérer
toutes ces données.
Alors, ouvrons ce dernier..
Et celui-ci, cette fois
s'agira d'un script de type "MonoBehaviour"
puisqu'il est attaché à notre
"DataController GameObject" et celui-ci
devra utiliser
"UnityEngine.SceneManagement".
C'est pourquoi nous devons écrire
Ici-haut dans le script:
« using UnityEngine.SceneManagement; »
pour qu'ainsi, nous puissions
charger nos scènes dans notre jeu.
Par la suite,
Nous ajouterons
un "public «Array» ( [ ] )
de type "RoundData",
que nous nommons:
" public RoundData [ ] allRoundData; "
Donc, un peu plus tard,
nous pourrons rallonger le jeu
Et y insérer plusieurs autres «Round»,
Mais pour l'instant nous n'en aurons
qu'un seul et unique.
Mais nous l'inscrirons ici avec un «array» [ ]
pour que nous puissions le rallonger
un peu plus tard dans cette session.
Ensuite, nous allons
configurer ce "GameObject"
pour qu'il ne se détruise pas
au chargement de notre jeu.
(DontDestroyOnLoad)
Nous allons donc faire appel
a la fonction "DontDestroyOnLoad"
Et poursuivre vers le "GameObject"
dont le script y est attaché.
Ce dont cela signifie,
est que normalement lorsque nous
chargeons une nouvelle scène,
chaque objet dans les scènes précédentes
qui ne sont plus activées, sont détruites.
En configurant cet objet avec
«DontDestroyOnLoad»
lorsque nous ouvrons une nouvelle scène,
rien ne se détruit dans la scène.
La façon de le voir par l'interface de Unity,
c'est en observant le seul objet qui
se divise dans le jeu et qui reviendra
chaque fois sous le nom de:
«DontDestroyOnLoad» ;
Alors, dans notre cas,
Configurons ceci avec «DontDestroyOnLoad»
Et ensuite nous allons écrire:
SceneManagement.LoadScene
puis nous allons charger le MenuScreen.
Maintenant,
La raison principale de ce script «DataController»,
est d'alimenter «RoundData» à notre «GameController»
Lorsque nous arriverons à cette scène
Nous allons donc déclarer une fonction «public»
Pour retourner un objet de type «RoundData»
que nous nommons: «GetCurrentRoundData».
Et dans ce cas nous allons écrire:
«return allRoundData [0]»
Dans ce cas nous savons que nous aurons
qu'uniquement «data» à notre roundData "0"
dans notre RoundData "0"
Mais si nous voulons élargir le tout
un peu plus tard, nous pourrions
créer un «int», pour spécifier
quelle donnée nous voulons retourner, etc.
Ok.
C'est tous ce que nous aurons
besoin pour l'instant, enregistrons le tout.
Retournons à Unity.
Et maintenant,
Avant de pouvoir charger une des scènes
que nous venons de créer,
Nous avons besoin de les ajouter
dans notre «Build Settings»
Donc, allons à «File» et «Build Settings»
Glissons d'abord notre scène
nommée: «Persistent»
Notre scène nommée «Persistent»,
sera celle qui sera chargée au départ
lorsque nous démarrerons notre application
et nous mènera directement
à notre scène «MenuScreen».
Lorsque le joueur joueras plusieurs
"Round" de notre jeu,
Il sera toujours automatiquement retourné
à notre scène «MenuScreen»
La scène «Persistent» sera toujours chargée
la première fois, lorsque le jeu démarrera,
Ensuite notre DataController gardera
la donnée en mémoire et ne sera pas détruite
Donc,
Nous allons ajouter la scène «Persistent»,
Ensuite, la scène «MenuScreen»
Et enfin, la scène «Game».
Ok.
Donc, maintenant elles sont disponibles
Les scènes peuvent être chargées.
Et on peut
Enregistrer notre «DataController»
Jouer.
Et
Ok, ça fonctionne.
Elles sont trop pareilles
Mettons l'arrière-plan de la
«Main Camera» noir
dans la scène «Menu Screen»
pour que vous puissiez voir
comme il faut ce qui se passe
dans la scène.
Donc voilà, on commence ici,
Il n'y a aucune caméra
et ça nous amène à
une scène noire,
n'est-ce pas?
Donc,
Ça fonctionne tel que prévu.
Immédiatement,
la scène «MenuScreen» démarre
Et maintenant, notre «DataController»
enclenche cette scène «DontDestroyOnLoad»
Dont laquelle elle ne sera pas détruite.
Alors, tout fonctionne tel que prévu.
Donc, je vais jeter un coup d’œil
rapide sur la "chat",
Et voyons voir,
si tout le monde se porte bien.