IX. Préparation du premier écran▲
Tout est prêt à ce stade pour commencer la programmation des écrans.
Chaque écran sera géré dans un module de classe indépendant : clScreenMenu, clScreenGame…
Chacun de ces modules héritera de l'interface définie dans le module clScreen.
Cet héritage se traduit dans le code avec l'instruction Implements.
On pourra alors dans l'objet jeu faire appel à un unique objet de type clScreen pour faire appel à l'écran en cours.
Afin de pousuivre avec la création de ce module d'interface, écrivons l'algorithme de déroulement du jeu.
On va ainsi mettre en évidence les propriétés et fonctions nécessaires à un écran.
oScreen = Nouvel écran de menu clScreenMenu
oCommand = Nouvel objet de commandes clCommand
oSharedData = Nouvel objet de données clSharedData
Affecte oCommand et oSharedData à oScreen
Début boucle de jeu
Exécute mise à jour des commandes dans oScreen
Exécute mise à jour de l'écran dans oScreen
Exécute mise à jour de l'affichage dans oScreen
Exécute la fonction d'attente dans oScreen
Si oScreen demande un changement d'écran
oScreen = Nouvel écran fonction de l'écran suivant dans oScreen
Affecte oCommand et oSharedData à oScreen
Fin Si
Fin boucle de jeuIX-A. L'interface d'écran clScreen▲
Dans ce paragraphe nous développons l'interface des écrans dans le module de classe clScreen.
Dans un module d'interface, nous écrivons uniquement un squelette.
Les fonctions, procédures ou propriétés ne seront pas exécutées dans ce module mais dans les modules en héritant.
Nous n'écrivons donc qu'un commentaire à intérieur.
Les objets oCommand et oSharedData étant transmis à chaque écran par l'objet Jeu, il est nécessaire de créer une propriété publique en écriture.
'------------------------------------------------------------------------
' Les objets Command et Shared sont en écriture public car ils seront
' transmis par l'objet jeu d'écran en écran
'------------------------------------------------------------------------
Public Property Set Command(poCommand As ClCommand)
'
End Property
Public Property Set SharedData(poSharedData As ClSharedData)
'
End PropertyOccupons nous maintenant des variables.
Le nom de l'écran suivant NextScreen doit pouvoir être lu ou écrit de n'importe où.
En effet on doit pouvoir accéder au nom de l'écran suivant :
- en lecture pour lire le nom de l'écran suivant lors d'un changement d'écran ;
- en écriture pour définir un écran suivant différent de celui par défaut.
Le flag de demande de changement d'écran ChangeScreen doit être en lecture uniquement
En effet on doit pouvoir tester la demande de changement d'écran depuis l'objet jeu.
'------------------------------------------------------------------------
' Propriété pour nom de l'écran suivant
' Public car doit être accessible de partout
'------------------------------------------------------------------------
Public Property Get NextScreen() As String
'
End Property
Public Property Let NextScreen(pNextScreen As String)
'
End Property
'------------------------------------------------------------------------
' Propriété pour flag de changement d'écran
' Lecture Public
'------------------------------------------------------------------------
Public Property Get ChangeScreen() As Boolean
'
End PropertyOn note également dans l'algorithme que l'objet jeu appelle des fonctions de :
- mise à jour des commandes pour tester l'appui de touches ;
- mise à jour de l'écran pour gérer l'écran ;
- mise à jour de l'affichage pour afficher sur le formulaire ;
- minuterie pour gérer le framerate.
On ajoute donc une fonction publique pour chacune de ces étapes.
'------------------------------------------------------------------------
' Functions à gérer dans les écrans
'------------------------------------------------------------------------
Public Function UpdateScreen() As Boolean
' Mise à jour de l'écran
End Function
Public Function UpdateCommand() As Boolean
' Mise à jour des commandes
End Function
Public Function DisplayScreen() As Boolean
' Affichage de l'écran
End Function
Public Function ScreenWait() As Boolean
' Minuterie d'attente
End FunctionLe module d'interface est prêt, nous pouvons maintenant créer le premier écran.
IX-B. Préparation du premier écran : le menu clScreenMenu▲
Le premier menu que nous allons créer est l'écran de menu.
Tout le code concernant le menu est écrit dans le module de classe clScreenMenu.
Ce module héritant de l'interface clScreen, la première étape est d'implémenter cette interface.
'***************************************************************************************
'* OBJET ECRAN DE MENU
'***************************************************************************************
Option Explicit
' Implémente l'interface de base des écrans
Implements ClScreenSi on compile le projet (Débogage => Compiler) on obtient une erreur.
Tout élément public (fonction, propriété, variable, procédure…) déclaré dans clScreen doit en effet être géré dans les modules d'écran qui en héritent.
Pour générer tout le code d'interface nécessaire, sélectionnez clScreen dans la liste déroulante de gauche au dessus du code VBA.
Puis sélectionnez chaque entrée dans la liste déroulante de droite pour générer les déclarations correspondantes.
Placez une apostrophe (') dans chacune des portions de code ajoutée pour éviter qu'elles ne disparaissent (s'il n'y a pas de code à l'intérieur, la compilation supprime les déclarations).
Voici le code obtenu, après ajout de commentaires :
'------------------------------------------------------------------------
' Implémentation des propriétés de l'interface
'------------------------------------------------------------------------
Private Property Get ClScreen_ChangeScreen() As Boolean
'
End Property
Private Property Set ClScreen_Command(RHS As ClCommand)
'
End Property
Private Property Let ClScreen_NextScreen(RHS As String)
'
End Property
Private Property Get ClScreen_NextScreen() As String
'
End Property
Private Property Set ClScreen_SharedData(RHS As ClSharedData)
'
End Property
'------------------------------------------------------------------------
' Mise à jour des commandes
'------------------------------------------------------------------------
Private Function ClScreen_UpdateCommand() As Boolean
'
End Function
'------------------------------------------------------------------------
' Mise à jour de l'écran
'------------------------------------------------------------------------
Private Function ClScreen_UpdateScreen() As Boolean
'
End Function
'------------------------------------------------------------------------
' Affichage de l'écran
'------------------------------------------------------------------------
Private Function ClScreen_DisplayScreen() As Boolean
'
End Function
'------------------------------------------------------------------------
' Minuterie d'attente
'------------------------------------------------------------------------
Private Function ClScreen_ScreenWait() As Boolean
'
End FunctionMaintenant le projet compile, mais il nous faut gérer toutes ces propriétés et fonctions.
Nous remarquons qu'aucune variable n'a été définie dans notre module clScreenMenu.
D'après le schéma des objets, nous avons besoin de 4 objets par écran.
' Objet pour commandes
Private oCommand As ClCommand
' Objet pour données partagées
Private oSharedData As ClSharedData
' Objet pour sons
Private oSound As ClSound
' Objet pour gdiplus
Private oGdi As ClGdiplusEt d'après l'algorithme de déroulement du jeu, nous avons besoin de deux variables :
- un flag booléen pour demander le changement d'écran ;
- et une variable contenant le nom de l'écran suivant.
' Indicateur pour changement d'écran
Private gChangeScreen As Boolean
' Nom de l'écran suivant
Private gNextScreen As StringPuis gérons les propriétés :
'------------------------------------------------------------------------
' Implémentation des propriétés de l'interface
'------------------------------------------------------------------------
Private Property Get ClScreen_ChangeScreen() As Boolean
ClScreen_ChangeScreen = gChangeScreen
End Property
Private Property Set ClScreen_Command(RHS As ClCommand)
Set oCommand = RHS
End Property
Private Property Let ClScreen_NextScreen(RHS As String)
gNextScreen = RHS
End Property
Private Property Get ClScreen_NextScreen() As String
ClScreen_NextScreen = gNextScreen
End Property
Private Property Set ClScreen_SharedData(RHS As ClSharedData)
Set oSharedData = RHS
End PropertyOccupons nous maintenant de l'initialisation de l'écran.
Cette initialisation a lieu dans l'événement Initialize lorsque l'objet est instancié.
Les objets oCommand et oSharedData sont transmis à chaque écran par l'objet Jeu.
Par contre, les autres objets sont spécifiques à chaque écran et doivent donc être créés à l'initialisation de l'écran.
'------------------------------------------------------------------------
' Initialisation de l'objet
' =>création des objets nécessaire à l'écran
'------------------------------------------------------------------------
Private Sub Class_Initialize()
Set oGdi = New ClGdiplus ' Objet pour graphiques
Set oSound = New ClSound ' Objet pour sons
End SubNous allons également définir un écran suivant par défaut dans cet événement.
Comme on est dans l'écran de menu, il n'y a pas vraiment d'écran suivant par défaut, le choix se fait par le menu.
Mettons tout de même un écran « quit » par défaut.
' Ecran suivant par défaut
gNextScreen = "quit"Il est maintenant grand temps de tester le code !
Créez un nouveau module (attention : pas un module de classe) : Insertion => Module.
Ecrivez-y une fonction de test :
Option Explicit
' Test de l'écran de menu
Function TestEcran()
Dim oScreen As ClScreen
Set oScreen = New ClScreenMenu
MsgBox oScreen.NextScreen
End FunctionCette fonction :
- déclare un objet de type clScreen ;
- instancie un objet de type clScreenMenu (qui hérite de l'interface clScreen) ;
- affiche un message contenant le nom de l'écran suivant.
Exécutez la fonction : le message attendu apparaît !
La base de notre écran est prête.
Elle pourra servir à la création des autres écrans car nous n'avons pas commencé à programmer le menu dans cet écran.
Mais il est difficile de continuer ainsi « en aveugle » à ce stade du projet.
Il faut désormais mettre en place la boucle de jeu dans l'objet Jeu (classe clGame) et l'intégrer au formulaire pour pouvoir ensuite commencer le développement graphique des écrans et tester l'affichage.