UnrealScripter #4

unrealscripter

VI. HUD

Attaquons-nous aujourd’hui à notre premier HUD. Comme je l’ai dit précédemment, j’ai codé le HUD avant tout pour contrôler que les modifications dans le code fonctionnaient ! Et cela a toujours été le cas dans mes projets. Il est important de savoir faire un HUD (même moche) afin de suivre en direct l’évolution des variables du jeu. Il est également possible, dans la même optique, d’ajouter des messages dans le console, mais ce n’est pas l’objet de ce tutoriel.

Une fois pris en considération qu’il n’y aura ici AUCUN souci esthétique, on va pouvoir se lancer. Avant tout, il existe désormais deux types de HUD dans l’UDK. Depuis la version de mai (attention à bien vérifier la version que vous utilisez) a été intégré Scaleform GFX, une technologie permettant l’affichage d’interfaces 3D interactives. L’avancée en termes graphiques est importante mais l’accessibilité est beaucoup moins évidente. Heureusement, il est toujours possible de créer des HUD à l’ancienne en ajoutant une simple ligne de code dans les defaultsproperties de TT_Game.uc :

bUseClassicHUD = true;

Surtout, n’oubliez pas de changer ça le jour où vous voulez faire une interface 3D !

Pour être honnête, je précise que l’on va ici utiliser une fonction qui ne vient pas de moi, DrawTexting(). Je l’ai adaptée à partir d’un tutoriel ou d’un exemple mais je ne sais plus d’où.

Commençons par créer le fichier, TT_HUD.uc :

TT_HUD extends UTHUD;

Je précise qu’il existe une classe UTTeamHUD qui prend en compte l’équipe dans laquelle on joue pour dessiner le HUD (simplement, ça permet de faire que si on est dans l’équipe bleue, certains textes et images du HUD se colorent en bleu). Je vous laisse donc adapter à ce que vous voulez faire. A ne pas oublier : dire à notre jeu qu’il doit utiliser ce HUD ! On doit doit ajouter la ligne suivante dans les defaultproperties de notre [b]TT_Game.uc[/b].

HUDType=Class’TT_HUD’

Ici, nous allons utiliser (comme toujours pour faire un HUD) des fonctions issues de Canvas.uc. Une nouvelle fois, je vous conseille d’aller jeter un coup d’oeil à cette classe pour voir un peu l’éventail de fonctions qui y existent.

simulated function DrawTexting (UTHUD H, float X, float Y, string Text)

{

if (H == None || H.Canvas == None) return;

// Simule une résolution de 1024*768

X = X * H.ResolutionScaleX;

Y = Y * H.ResolutionScale;

H.Canvas.Font = class’Engine’.static.GetMediumFont();

H.Canvas.SetPos (X, Y);

H.Canvas.DrawColor=WhiteColor;

H.Canvas.DrawText (Text, false);

}

En observant les variables de cette fonction, on a d’abord un HUD (pour savoir pour quel joueur on affichera le texte), des positions X et Y sur l’écran et le texte à écrire. La première condition (H == None || H.Canvas == None) vérifie si le HUD cité correspond à quelque chose et si ce n’est pas le cas, la fonction ne fait rien. Ensuite, la première partie simule un écran d’une taille donnée. En effet, chaque joueur ayant une résolution différente, il faut arriver à coder quelque chose de générique qui fonctionnera sur chaque écran. Globalement, l’idée est d’arriver à une notion de pourcentage plutôt que de nombre de pixels.
Les conditions suivantes sont celles qui vont déterminer la police d’écriture. On utilise ce genre de fonction pour les appeler :

class’Engine’.static.GetMediumFont()

On verra dans un autre tutoriel comment changer les polices d’écriture par défaut.

On utilise ensuite SetPos pour déterminer la position, DrawColor pour la couleur et DrawText pour dessiner le texte. On peut remarquer qu’une fonction, DrawText(), existe donc déjà. Cependant, en créant la notre, on la complexifie beaucoup (il suffit de voir déjà le nombre de variables) et on l’adapter à nos besoins. Il existe également une fonction qui dessine un texte en le centrant. Sans surprise, on trouve DrawTextCentered() dans Canvas.uc.

Pour le moment, on a codé notre base, c’est-à-dire la fonction qui nous permettra d’afficher du texte. Maintenant on va coder la fonction qui permettra d’exécuter cette fonction (un grand classique). Appelons la DrawLevel. Cette fonction a pour but d’afficher le niveau du joueur et son nombre de points d’expérience. Pour cela, on aura shématiquement deux lignes lançant deux fois la fonction DrawText. Reste à récupérer le niveau et points d’XP. Pour cela, on va créer deux nouvelles fonctions…

function int PickLevel(Controller c) //Récupère le Niveau

{

local int WhatLevel;

WhatLevel = TT_PRI(c.PlayerReplicationInfo).Level;

Return WhatLevel;

}

Encore une technique classique. Ici, la fonction PickLevel a pour variable un Controller, car on veut récupérer le niveau d’un joueur précis. On remarque dans la déclaration de la variable le « int ». Cela veut dire que quand je lance la variable, elle va me donner un nombre entier. Par exemple, si je fais PickLevel(Joueur); cela donnera 1, 2, 3 ou 4, etc. On peut évidemment déclarer des functions avec des floats, strings, booléens, etc.

Ici, on a donc déclaré une variable locale, on la définit comme égale au niveau du joueur. Et ensuite on retourne cette variable. Le résultat de la fonction est donc « WhatLevel ». Rien de bien compliqué ici. Je vous laisse faire la même fonction PickXP qui est exactement la même, il suffit de changer « Level » en « XP » (essayez de la refaire sans regarder l’autre, ce sera formateur !).

Maintenant que l’on a toutes nos fonctions, on peut passer à celle qui nous intéresse réellement !

simulated function DrawLevel(UTHUD H)

{

DrawTexting (H,10, 180,  » XP :  » @ PickXP(PlayerOwner));

DrawTexting (H,10, 200,  » Level :  » @ PickLevel(PlayerOwner));

}

A force de faire des fonctions annexes, notre fonction de base se trouve bien simplifiée ! Il faut comprendre que le fait de faire des sous-fonctions permet d’éviter de s’embrouiller dans les variables et surtout de les réutiliser ailleurs. Typiquement, une fonction comme DrawLevel sera certainement utilisable ailleurs (pour afficher des résultats par exemple). On remarque que j’ai décalé en hauteur (3ème variable, Y) les textes pour qu’ils ne soient pas l’un sur l’autre. La variable PlayerOwner est à retenir. C’est un PlayerController est défini dans HUD.uc (et donc aussi à UTHUD.uc qui en dérive) et désigne le joueur qui utilise ce HUD.

Terminé ? Pas du tout ! Nous n’avons pas lancé la fonction DrawLevel ! Pour cela, rien de compliqué, le tout c’est ne pas oublier de le faire !

function DisplayScoring()

{

Super.DisplayScoring();

DrawLevel (self);

}

La fonction DisplayScoring affiche le score (ha bon ?). On y ajoute discrètement notre fonction. Ici aussi, il est intéressant de voir la variable « self » qui dit donc que DrawLevel doit utiliser le HUD dans lequel il est lui-même. Cela peut paraître évident, mais ça ne l’est pas du tout. Par exemple, on pourrait très bien faire un jeu qui afficherait les points de vie de ses coéquipiers !

Voilà, c’est tout pour aujourd’hui. Notre HUD est très simple, voir moche mais permet de jouer en visualisant son niveau et ses points d’XP. Avec nos compétences actuelles, on peut très bien afficher également le nombre de points d’XP restants jusqu’au prochain niveau. N’hésitez surtout pas à utiliser la base du code pour l’adapter à vos besoins.

Dans le prochain tutoriel, on tentera (j’espère) le mode Furie !

Laisser un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *

*