S h a d . devblog

[Tutorial] - 03 - Un premier mode de jeu

Aloïs Deniel — Sat, 26 Jun 2010 21:19:00 +0100

Nous allons enfin commencer à coder, et pour cela, j'ai choisi de vous montrer un petit exemple de jeu très simple dérivé du "Deathmatch" de "Unreal Tournament" fourni avec chaque version de l'UDK.

Les règles du jeu

Bon alors, on va commencer tout en douceur. Le but va être ici très simple : augmenter la taille des personnages des joueurs en fonction du nombre de frags consécutifs qu'ils exécutent. Nous aurons juste besoin de créer une nouvelle classe pour réaliser cela, nouvelle classe qui sera hérité de la classe "UTDeathmatch" (elle-même héritée indirectement de "GameInfo").

Le code

Voilà tout d'abord une vue d'ensemble de la classe que nous allons faire. Essayez de comprendre par vous même dans un premier temps, puis passez à la suite.

class Tutorial_Game extends UTDeathmatch;

function ScoreKill(Controller Killer, Controller Other)
{

    local float NewScale;

    super.ScoreKill(Killer,Other);

    if(Killer != none && Killer != Other)
    {
        if(Killer.Pawn != none && Killer.Pawn.DrawScale< 2.0 )
        {

            NewScale = Killer.Pawn.DrawScale + 0.2;

            Killer.Pawn.SetDrawScale(NewScale);
            Killer.Pawn.BaseEyeHeight = Killer.Pawn.default.BaseEyeHeight * NewScale;
            Killer.Pawn.CylinderComponent.SetCylinderSize
            (Killer.Pawn.default.CylinderComponent.CollisionRadius * NewScale,
            Killer.Pawn.default.CylinderComponent.CollisionHeight* NewScale);
            Killer.Pawn.GroundSpeed = Killer.Pawn.default.GroundSpeed * NewScale;
            Killer.Pawn.JumpZ = Killer.Pawn.default.JumpZ * NewScale;
            Killer.Pawn.bCanCrouch = false;

        }

        Broadcast( self,"Taille de"@Killer.GetHumanReadableName()@":"
        @Killer.Pawn.DrawScale,);
    }

}

Quelques explications

Bon, étudions un peu cela en détail :

class Tutorial_Game extends UTDeathmatch;

Comme prévu, notre mode de jeu va garder toutes les caractéristiques du "Deathmatch" de UT, d'où cet héritage.

function ScoreKill(Controller Killer, Controller Other)

Il y a cependant quelque chose a modifier pour arriver à nos fins : la fonction "ScoreKill(Controller Killer, Controller Other)" qui est appelé à chaque frag. Nous allons donc surcharger cette fameuse fonction afin de modifier la taille de "Killer".

local float NewScale;

Cette ligne est une déclaration de variable temporaire (grâce au mot "local", et toujours placée en début de fonction). Cela signifie que cette variable de type "float" ne vivra que le temps de l'exécution de la fonction. Cette variable "NewScale" va permettre de stocker la nouvelle échelle de taille du personnage.

super.ScoreKill(Killer,Other);

Bon alors ... si vous avez quelques notions de programmation orientée objet vous devez savoir que le mot clé "super" permet d'appeler la fonction courante de la classe mère. Cette ligne va donc permettre de faire le calcul de score en se basant sur la fonction "ScoreKill" de la classe "UTDeathmatch". Nous pourront ensuite rajouter les quelques fonctionnalités que nous souhaitons intégrer au jeu. Cela permet de nous éviter un énorme copier/coller de la fonction originale.

Si vous avez suivi le cours précèdent, vous devez savoir que le personnage du joueur est un "Pawn". Il est très simplement référence par un attribut de nom de "Pawn" dans la classe "Controller" et est donc très facile d'accès ("NomDuController.Pawn"). De la même manière on peut accéder à l'attribut "DrawScale" de la classe "Pawn" ("NomDuPawn.DrawScale") qui, comme son nom l'indique, définie l'échelle du model du joueur. Il faut cependant faire attention, car quelques variables (dont cette dernière) ne peuvent pas être assignées directement ( "~.DrawScale = 5;" n'est pas autorisé), mais il existe en général une fonction (dont le nom est souvent "Set + NomDeLaVariable") qui permet de la changer (ici "SetDrawScale" donc).

>if(Killer != none && Killer != Other)

La première conditionnelle permet de vérifier deux chose : que le tueur existe (le joueur peut être tué par le décor ou autre on ne sait jamais) et que le tueur n'est pas le tué. Si ces deux conditions sont vérifiées on exécute le code principal de la fonction.

if(Killer.Pawn != none && Killer.Pawn.DrawScale< 2.0 )

On trouve ensuite à nouveau une conditionnelle qui vérifie que le "Killer" possède bien un "Pawn", mais aussi que l'échelle actuelle du joueur est inférieure à deux fois la taille normale. Si toutes ces conditions sont vérifiées, on va enfin passer au changement d'échelle.

NewScale = Killer.Pawn.DrawScale + 0.2;

Le calcul de changement d'échelle va se faire très simplement : on va attribuer à "NewScale" la valeur actuelle du "DrawScale" plus "0.2". Le joueur pourra donc grossir au maximum cinq fois et obtenir une échelle deux fois plus grande que la normale.

Killer.Pawn.SetDrawScale(NewScale);
Killer.Pawn.BaseEyeHeight = Killer.Pawn.default.BaseEyeHeight * NewScale;
Killer.Pawn.CylinderComponent.SetCylinderSize
(Killer.Pawn.default.CylinderComponent.CollisionRadius * NewScale,
Killer.Pawn.default.CylinderComponent.CollisionHeight* NewScale);
Killer.Pawn.GroundSpeed = Killer.Pawn.default.GroundSpeed * NewScale;
Killer.Pawn.JumpZ = Killer.Pawn.default.JumpZ * NewScale;
Killer.Pawn.bCanCrouch = false;

Bon, maintenant que nous avons la nouvelle échelle, nous pouvons procéder aux changements. Nous commençons par redéfinir l'echelle du model du personnage. La ligne suivante va permettre de changer la hauteur des yeux du personnage (et donc de la camera). Vous avez peut-être remarqué le mot clé "default" qui permet d'obtenir la valeur par défaut de l'attribut (celle entrée dans les "Default Properties" donc). Nous changeons donc la hauteur proportionnellement à l'échelle de taille. Il faut ensuite changer les collisions pour qu'elles s'adaptent à la nouvelle taille. J'ai décidé de changer la vitesse du joueur et la hauteur des sauts pour que tout soit plus logique. Ici, nous avons donc encore la même façon de faire.

Broadcast( self,"Taille de"@Killer.GetHumanReadableName()@":"
@Killer.Pawn.DrawScale,);

Cette dernière ligne s'occupe simplement d'afficher la tailler des différents joueurs. Vous pouvez remarquer l'operateur "@" qui concatène (colle) deux chaînes en rajoutant un espace (contrairement à "$" qui n'en rajoute pas) .

Tester le mode de jeu

Pour tester ce code, commencez par enregistrer votre fichier de classe dans le dossier créé dans le premier tutorial '"du nom de "Tutorial" justement). Il faut obligatoirement donner à ce fichier le même nom que le nom de la classe. Enregistrez donc cela sous le nom "Tutorial_Game.uc".

Notre première classe.

Ouvrez maintenant "UnrealFrontend" et compilez votre code qui ne doit normalement pas produire d'erreur. Pour tester le jeu sur la map "DM-Deck", entrez le texte suivant dans "Map To Play" : "DM-Deck?game=Tutorial.Tutorial_Game", puis cliquez sur "Launch".

Aucune erreur ... tout va bien !

Et voilà, notre mode de jeu à l'aire de bien fonctionner.

Ohlala, c'est quoi ce machin !

[Tutorial] - 02 - Organisation des classes

Aloïs Deniel — Sat, 26 Jun 2010 16:04:00 +0100

Dans ce second tutorial, nous allons jeter un rapide coup d'œil au contenu du dossier "~/Development/Src", et tenter de comprendre un minimum l'organisation de quelques classes livrées avec l'UDK et très importantes à la création de votre jeu.

Il est évident qu'il va falloir se renseigner un peu sur le fonctionnement et l'organisation des objets que EpicGames nous à livré avant de nous lancer. Nous allons en effet réutiliser au maximum le travail déjà effectuer, nous baser sur tout cela pour créer de nouvelles classes.

Quelques classes importantes

Commençons par un schéma de quelques classes que je considère comme indispensables :

En partant du principe que la notion de programmation orientée objet est familière pour vous, vous avez sans doute remarqué que la plupart des classes héritent de la classe "Actor". Ayez donc toujours le réflexe, lorsque vous étudiez une classe précise, d'ouvrir aussi toutes les classe dont hérite cette dernière, car, je vous le rappelle, toutes les fonctions et attributs des classes héritées sont disponibles dans la classe fille.

D'autre part, ne pensez pas qu'il suffit de connaître cette poignée de classes pour devenir un "génie du UnrealScript" ! En effet, la plupart du travail doit être fait par vous même, en étudiant au maximum les différentes classes mises à disposition.

Pourquoi cette sélection ?

Ce choix est purement arbitraire, considérant que ces classes permettent d'aboutir à quelques résultats probants sans trop se plonger dans les classes les plus complexes. Je pense que se familiariser avec ces quelques exemples permettra d'avoir une bonne approche du fonctionnement du moteur (c'est en tout cas comme cela que j'ai appris).

Je vais maintenant vous expliquer cas par cas, la raison de ce choix :

Actor
Comme déjà introduit, une grande majorité des éléments de l'UDK sont basés sur cette classe. Elle instaure des fonctionnalités que l'on retrouvera dans pratiquement chaque classe et se doit donc d'être étudiée. En effet, c'est dans cette classe que les coordonnées, l'orientation, la vitesse sont définies, tout comme des fonctions incontournables telles que "Tick" (mise à jour des objet au cours du temps), "Trace" (test de collision avec l'environnement), "SetTimer" (execution d'une fonction au terme d'un chrono), etc ...
ActorComponent
Pour simplifier, ces objets peuvent être "attachés" à des "Actors" très simplement. C'est souvent eux qui vont définir l'aspect physique d'un "Actor". On va par exemple attacher un model 3D ("StaticMeshComponent" ou "SkeletalMeshComponent"), un éclairage ("DynamicLightEnvironmentComponent"), une projection de texture ("DecalComponent"), etc ..
GameInfo
C'est cette classe qui va définir toutes les règles de jeu, la manière de marquer des points, mais aussi le type de joueurs ou le HUD du mode de jeu par exemple.
Controller/PlayerController
Chaque joueur (qu'il soit humain ou virtuel) dans le jeu est en fait représenté par un "Controller". Comme son nom l'indique, le "Controller" va donner des ordres à une "marionnette" qui sera sa représentation physique dans le monde. Le joueur n'est donc pas, comme on pourrait le croire, le personnage qui bouge dans les niveau, mais le "Controller" qui lui dirige le personnage ... Vous avez saisi ?
Pawn
C'est justement le "Pawn" (en français "Pion") qui est cette "marionnette" évoquée précédemment. C'est le "Pawn" qui possède toutes les caractéristiques liées au déplacement, mouvements, capacités .. mais aussi des points de vie. Lorsque le "Pawn" controllé par un "Controller" n'a plus de points de vie, il est alors supprimé et un nouveau "Pawn" entre donc sous le contrôle du "Controller" concerté (je parle évidement ici des jeux où vous avez plusieurs vies).
Volume/TriggerVolume
Bon, là je vais vous avouer que c'est loin d'être une priorité ... mais je pense tout de même qu'il y a matière à s'amuser avec les "Volumes". En effets, les "Volumes" sont souvent au centre du gameplay car il permettent de changer le comportement du joueur, ou de déclencher certains mécanismes lorsque les joueurs entre dans ces derniers.
Weapon
Modifier une arme est surement la première chose à faire. C'est d'une part simple a faire, mais aussi extrêmement jouissif lorsque l'on commence à coder sur ce moteur. Il est très facile de changer quelques attributs des armes de la demo fournie avec l'UDK et d'obtenir des résultats très surprenants !
KActorSpawnable
Cet "Actor" réagi tout simplement à la physique. Il est donc très pratique pour créer toutes sortes de balles, grenades, etc ...

[Tutorial] - Sommaire

Aloïs Deniel — Sat, 26 Jun 2010 12:37:00 +0100

Voici le sommaire de tous les cours disponibles sur ce blog.

Unreal Development Kit

01 - Introduction
- Qu'est ce que l'UDK ?
- Téléchargement de l'UDK
- Hiérarchie des dossiers
- Configuration
- Quel éditeur choisir ?
02 - Organisation des classes
- Quelques classes importantes
- Pourquoi cette sélection ?
03 - Un premier mode de jeu
- Les règles du jeu
- Le code
- Quelques explications
- Tester le mode de jeu

[Tutorial] - 01 - Introduction

Aloïs Deniel — Fri, 25 Jun 2010 22:59:00 +0100

Dans ce premier tutorial, nous allons commencer par tout configurer pour taper nos premières lignes de codes sans encombres dans les tutoriaux qui suivront. Nous allons donc voir où se procurer l'UDK, où placer nos fichiers de code et comment compiler tout cela.

Qu'est ce que l'UDK ?

Avant toute chose, vous ne savez peut être pas ce qu'est l'UDK. L'Unreal Development Kit, comme sont nom l'indique plutôt clairement, est une mise à disposition par EpicGames d'une suite d'outils de développement pour la dernière version de son fameux moteur 3D : l'Unreal Engine 3 (utilisé dans de nombreux jeux-vidéo tels que Gears Of War, Unreal Tournament III, Bioshock, Mass Effect, etc ...). Tant qu'aucun profit n'est fait à partir de cela, l'utilisation de tous ces outils pour le développement, ainsi que la publication d'un jeu-vidéo sont complètement gratuites.

Bounty Arms est un parfait exemple d'utilisation de l'UDK

Téléchargement de l'UDK

Le simple téléchargement du fichier d'installation vous donne accès à un bon nombre d'outils : sources, éditeur de maps (qui comprend lui même énormément d'outils), demo de UT et SpeedTree. Télécharger donc les centaines de MB de la dernière version et installez-la dès à présent via le lien livré ci-dessous. Je ne saurais que vous conseiller de télécharger la dernière version disponible, l'UDK étant encore en beta à l'heure où je vous parle, EpicGames faisant un énorme travail pour apporter un tas d'améliorations chaque mois !

Page de téléchargement officielle

Hiérarchie des dossiers

Lors de cette série de tutoriaux, je ne me concentrerais que sur l'aspect programmation de l'UDK, je ne ferais donc pas de descriptif détaillé de chaque dossier créé lors de l'installation. En effet, le dossier sur lequel je me concentrerais est le dossier "~/Development/Src" du répertoire d'installation, qui contient évidemment une grande partie des sources du moteur. Toutes les classes (fichiers portant l'extension "~.uc") qui se trouvent dans ce dossier pourront être compilées.

Pour créer votre premier projet, il va d'abord falloir créer un dossier du nom de ce dernier dans le dossier "~/Development/Src".

Le projet d'exemple présenté ici aura pour nom "Tutorial", mais vous pouvez évidement procéder avec un nom différent.

Il faut ensuite, de la même façon créer un dossier "Classes" dans le dossier de votre projet. C'est dans ce nouveau dossier que vous devrez placer vos classes (fichiers portant l'extension "~.uc").

Ce dossier contiendra toutes les classes de votre nouveau projet.

Configuration

Maintenant que vous savez où placer votre code, nous allons indiquez au moteur où seront vos classes afin qu'il puisse les compiler. Ouvrez donc le fichier "UDKEngine.ini" placé dans le dossier "~\UDKGame\Config" avec n'importe quel éditeur de texte. Cherchez la ligne ";ModEditPackages=MyMod" de la catégorie "[UnrealEd.EditorEngine]", puis remplacez là par (ou rajoutez la ligne juste après) "ModEditPackages=Tutorial".

C'est dans ce fichier que l'on indique au moteur où se trouve les classes de notre projet à compiler.

Voilà, vous pouvez désormais compiler votre code. Pour cela, ouvrez le logiciel "Unreal Frontend" livré avec l'UDK, puis cliquez sur "Make > Full Recompile". Après quelques secondes, vous avez le résultat de la compilation dans la zone de droite. Il y a une alerte, ce qui est normal étant donné qu'il n'y a aucune classe à compiler pour le moment.

C'est dans UnrealFrontend que l'on re-compile tout le code de l'UDK.

Quel éditeur choisir ?

Pour taper vos lignes de codes, il n'y a pas de réel éditeur complet dédié à l'UnrealScript, mais il existe tout de même quelques solutions :

A vous de faire un choix. Personnellement j'utilise Notepad++, bien que moins complet que nFringe , j'apprécie sa simplicité.