Suite à une augmentation notable mon activité professionnelle, je suis dans l'incapacité de poursuivre la rédaction d'articles pour le moment.
Dès que cela ce sera un peu calmé, je reprendrai en main ce blog.
Suite à une augmentation notable mon activité professionnelle, je suis dans l'incapacité de poursuivre la rédaction d'articles pour le moment.
Dès que cela ce sera un peu calmé, je reprendrai en main ce blog.
En relation directe avec la gestion de l'apprentissage, on trouve la gestion de la difficulté.
La difficulté est au gameplay ce que sont les rebondissements au scénario : elle doit être source de motivation pour le
joueur en lui proposant des défis à la hauteur de sa maîtrise du jeu. Trop de difficulté tuera le jeu aussi sûrement que pas assez.
La formalisation de la difficulté n'est pas une chose aisée car cette dernière est très subjective. L'idée pour ce chapitre est plus de mettre en avant la progression de cette dernière, que sa
réalité dans le jeu, qui sera d'ailleurs souvent plus du ressort du Level Design.
On distingue principalement deux types de progression de la difficulté :
- la progression linéaire propose une croissance régulière de la difficulté : on pourrait presque l'assimiler à un cas particulier de la progression par palier, où les paliers sont absents. Une telle progression n'est pas adaptée à tous les jeux car elle nécessite une certaine constance dans le gameplay.
- la progression par palier est plus populaire car elle permet de plus facilement renouveler le jeu et d'intégrer progressivement de nouveaux éléments de gameplay. Généralement les paliers à faible progression de difficulté serviront aux phases d'apprentissage tandis que les phases à plus forte progression valideront les acquis du joueur. De plus, cette progression s'adapte aussi plus facilement aux jeux scénarisés car elle se calquera sur le découpage scénaristique.
- la progression exponentielle est à éviter car elle rebutera certains joueurs peu expérimentés. On peut se trouver face à ce type de progression dans les jeux dont les phases d'apprentissage sont courtes. Ce type de progression se trouve aussi dans les phases finales des jeux, elle sert alors à accentuer l'impression de "force d'opposition".
La progression adaptative consiste, quant à elle, à adapter la difficulté du jeu au joueur : une IA plus ou moins complexe étudiera la façon de jouer du joueur, et distillera plus ou moins de bonus/malus. En l'occurrence il s'agit plus d'un régulateur que d'un réel type de progression, mais ses règles de fonctionnement devront être indiquées dans ce chapitre.
En fonction du jeu, on pourra choisir de présenter un tableau donnant une durée approximative de jeu avec un niveau de difficulté correspondant, ou préférer un graphique que l'on prendra soin de commenter.
Dernier point, il ne faut pas oublier que la difficulté globale dans un jeu peut provenir de différents éléments :
- la complexité liée au Level Design
- la complexité liée à la jouabilité
- la complexité liée au scénario
Les fondamentaux relatifs à l'écriture d'un scénario de jeu vidéo restent les mêmes que pour d'autres supports, comme les livres ou les films. La seule vraie différence est la possibilité que
peut avoir le scénariste, de profiter de l'aspect interactif du jeu, pour proposer une trame plus complexe. Mais il dispose aussi d'une contrainte supplémentaire : tous les scénarios n'ont pas le
même rendu en fonction du jeu auquel ils sont destinés.
Dans l'absolu, le scénario se base donc sur une ou plusieurs intrigues, qui se suivent ou se déroulent en parallèle. Chaque intrigue se décomposant elle-même en trois étapes distinctes :
- La pose du problème : il s'agit dans un premier temps d'amener l'intrigue au joueur, ou le joueur à l'intrigue. Cette phase initiale doit
permettre au joueur de prendre conscience de la mission qui lui incombe. Celle-ci peut-être plus ou moins progressive en fonction du type de jeu. Dans un jeu de baston,
l'intrigue ne constitue pas un élément clef du jeu, il sera généralement formalisé par des cinématiques : le joueur sera rapidement et relativement brutalement confronté à cette dernière. Par
contre, dans un RPG, la mise en place de l'intrigue peut-être beaucoup plus progressive, passant par la collecte d'informations, la rencontre avec des PNJ ou des évènements particuliers.
- La réalisation de l'intrigue : cette phase, généralement la plus développée, est une phase pendant laquelle le joueur va collecter des
informations complémentaires sur l'intrigue afin de lui trouver une solution. L'accent peut être mis autant sur la recherche de la solution que sur ça mise en oeuvre. Là encore, le type
de jeu auquel est destiné le scénario va influencer le contenu : pour un jeu orienté action, la phase de recherche de solution sera généralement plus simple, alors que pour un jeu plus porté sur
la réflexion, la phase de recherche sera nettement plus développée, tout cela tenant au fait que le gameplay et les possibilités d'actions entre ces jeux sont différents.
- La conclusion : la conclusion de l'intrigue sert à poser la nouvelle situation. Elle doit surtout permettre au joueur de
comprendre s'il a réussi ou échoué dans sa mission. Tout comme pour la première phase de l'intrigue, cela peut se faire plus ou moins en douceur en fonction du jeu : une cinématique montrant le
joueur victorieux peut-être suffisante, mais proposer au joueur de parcourir un monde libéré ou de constater sa notoriété auprès de PNJ peut-être plus valorisant.
La structure la plus employée est celle de l'intrigue principale, fil conducteur du jeu, autour de laquelle viennent graviter des intrigues secondaires, avec un rapport plus ou moins ténu avec
l'intrigue principale, et devant participer à l'immersion du joueur.
1- codage RLE
Le codage RLE (Run Length Encoding), consiste à coder une première valeur correspondant au nombre de fois où la seconde est répétée.
Concrètement, il se traduit de la façon suivante :
Octet 1 :
valeur de 1 à 255 : répéter autant de fois l'octet suivant
valeur à 0 : l'octet suivant indique une opération spéciale
Octet 2 :
si octet 1 entre 1 et 255, le répéter le nombre de fois correspondantes
si octet 1 à 0 :
valeur de 0 : fin de ligne atteinte, passer à la ligne suivante
valeur de 1 : fin de l'image
valeur de 2 : les deux octets suivants indique un décalage de pointeur dans l'image, avec 1 octet pour le nombre de colonnes et 1 octet pour le nombre de lignes.
valeur de 3 à 255 : nombre d'octets non compressés suivants.
Le codage RLE 4 bits est utilisé pour une image en 16 couleurs, le codage en 8 bits pour image en 256 couleurs.
Si le nombre d'octets obtenu est impair, on en ajoutera un à 0 à la fin.
Exemple pour une image en 256 couleurs, soit avec un codage RLE 8 bits:
00001000 00000011 00000000 00000001
Equivaut à l'image :
00000011 00000011 00000011 00000011 00000011 00000011 00000011 00000011
00001000 00000011 00000000 00001000 00001111 11111111 00000001 10101010 01010101 00110011 11001100 11110000 00000000 00000001
Equivaut à l'image :
00000011 00000011 00000011 00000011 00000011 00000011 00000011 00000011 00001111 11111111 00000001 10101010 01010101 00110011 11001100
2- Gestion de la palette et codage de l'image
La palette n'est utilisée que pour les images en 16 et 256 couleurs.
Donc, pour le codage de l'image proprement dite :
Pour les images monochromes, la valeur 1 est affectée pour les pixels de la couleur d'avant-plan et 0 pour les pixels de la couelur d'arrière-plan, directement au niveau du codage de l'image.
Pour les images en 16 couleurs, chaque groupe de 4 bits pointe une couleur de la palette.
Pour les images en 256 couleurs, chaque octets pointe une couleur de la palette.
Pour les images en 16 millions de couleurs, chaque pixel est directement codé au niveau de l'image.
Un point important : le codage de l'image se fait en partant du point inférieur gauche de l'image, puis il se fait vers la droite et vers le haut.
3- Structure C++
BitmapFileHeader : Entête de fichier
UINT bfType
DWORD bfSize
UINT bfReserved1
UINT bfReserved2
DWORD bfOffBits
BitmapInfoHeader : Informations sur l'image
DWORD biSize
LONG biWidth
LONG biHeight
WORD biPlanes
WORD biBitCount
DWORD biCompression
DWORD biSizeImage
LONG biXPelsPerMeter
LONG biYPelsPerMeter
DWORD biClrUsed
DWORD biClrImportant
TRGBQUAD : codage des couleurs pour la palette ou l'image
BYTE rgbBlue
BYTE rgbGreen
BYTE rgbRed
BYTE rgbReserved
Voici, plus ou moins brut, la structure d'un fichier bitmap (BMP).
Un second article viendra en complément pour éclaircir certains points.
Octets 1-2 : Signature
Elle permet d'identifier l'origine ou la nature du BMP. Les valeurs admises sont les suivantes :
- BM pour une image Bitmap Windows.
- BA pour une image Bitmap OS/2.
- CI pour une une icone couleur OS/2.
- CP pour un pointeur de couleur OS/2.
- IC pour une icone OS/2.
- PT pour un pointeur OS/2.
Octets 3-6 : taille du fichier.
Il s'agit de la taille totale du fichier, exprimée en octets.
Octets 7-10 : doivent être à 0.
Octets 11-14 : offset de l'image
Cela correspond à la taille de la première partie du fichier, y compris la palette, jusqu'au début du codage de l'image proprement dite.
Octets 15-18 : nombre d'octet jusqu'à la palette, ou l'image s'il ny a pas de palette.
Octets 19-22 : largeur de l'image en pixels.
Octets 23-26 : hauteur de l'image en pixels.
Octets 27-28 : nombre de plans.
Cette valeur est toujours 1.
Octets 29-30 : nombre de bits servant au codage de la couleur dans l'image.
Les valeurs admises sont 1, 4, 8 et 24.
Avec :
1 pour une image monochrome
4 pour une image en 16 couleurs
8 pour une image en 256 couleurs
24 pour une image en 16 millions de couleurs, on ne compte pas l'octet réservé (voir ci-dessous)
Octets 21-34 : type de compression.
Les valeurs admises ont les suivantes :
0 : pas de compression
1 : codage RLE de 8 bits par pixel
2 : codage RLE de 4 bits par pixel
3 : codage bitfields
Octets 35-38 : taille de l'image proprement dite en octets, soit le nombre d'octets entre la fin de l'entête s'il ny a pas de palette, ou la fin de la pallette, jusqu'à la
fin du fichier.
Octets 39-42 : résolution horizontale, en pixels par mètre, peut-être laissé à 0
Octets 43-46 : résolution verticale, en pixels par mètre, peut-être laissé à 0
Octets 47-50 : nombre de couleurs de la palette.
Octets 51-54 : nombre de couleurs importantes de la palette.
[palette de couleurs, sauf pour les images en 16 millions de couleurs et les monochromes]
octet 1 : codage du bleu.
octet 2 : codage du vert.
octet 3 : codage du rouge.
octet 4 : réservé.
[Image 2 monochrome]
bit 1 : référence pour la couleur du premier pixel.
bit 2 : référence pour la couleur du deuxième pixel.
....
[Image 16 couleurs]
bits 1-4 : référence dans la palette pour la couleur du premier pixel.
bits 5-8 : référence dans la palette pour la couleur du deuxième pixel.
...
[Image 256 couleurs]
octet 1 : référence dans la palette pour la couleur du premier pixel.
octet 2 : référence dans la palette pour la couleur du deuxième pixel.
...
[Image 16 millions de couleurs]
octet 1 : codage du bleu.
octet 2 : codage du vert.
octet 3 : codage du rouge.
octet 4 : réservé .
2.2.7 Gestion de l'apprentissage et aides
Dans les paragraphes précédents, il a fallut décrire point par point
tous les éléments avec lesquels le joueur sera en interaction. Des règles ont aussi été édictées afin de gérer le monde virtuel que sera le jeu une fois terminé.
Le choix des méthodes d'apprentissage à mettre en oeuvre dépendra beaucoup du type de jeu que l'on souhaite réaliser. Ici il faudra surtout indiquer comment on accède à ces dernières, et quels en
seront les objectifs en terme de connaissances à acquérir par le joueur, surtout pour les didacticiels. Une fois encore, rappelez-vous que ces informations seront utilisées par le ou les
Level-Designers : il faudra donc être toujours aussi précis.
Note : Il est possible de distinguer les "aides" des méthodes d'apprentissage, ce n'est clairement pas une obligation si l'on considère qu'une
aide est une méthode d'apprentissage passive, ou "méthode d'apprentissage par explication".
I- L'intégration des méthodes d'apprentissage
Même avec un jeu particulièrement 'instinctif', comme peuvent l'être par exemple bon nombre de petits jeux Flashs que l'on trouve sur le net, il est toujours utile de guider le joueur dans ses
premiers pas afin qu'il profite rapidement de la meilleure expérience possible du jeu : la gestion de l'apprentissage est donc un facteur clé pour un jeu, et cela à au moins deux niveaux
:
- pour les jeux 'gratuits' : abandonner le jeu n'est pas coûteux pour le joueur, il
faut donc prendre soin de soigner son apprentissage afin qu'il continue à y jouer.
- pour les
jeux 'complexes' : ne pas donner accès à certaines informations sur le fonctionnement du jeu peut le rendre incompréhensible ou handicaper trop gravement le joueur qui ne les auraient
pas découvertes ou apprises par l'expérience, avec au final un mauvais point pour l'équipe ayant produit le jeu et un a priori négatif pour ces prochaines
productions.
Des livres ont été écrits sur le sujet, des débats sont encore ouverts... Il existe de nombreuses méthodes d'apprentissage différentes, toutes disposant de leurs avantages et de leurs
inconvénients. Cela ne sera pas débattu dans cet article.
Il y a toutefois quelques points à mettre en avant. D'une part, l'apprentissage est une phase obligatoire pour le joueur, quelle que soit sa forme, afin qu'il maîtrise le jeu.
D'autre part, l'efficacité d'une méthode d'apprentissage est à mettre en rapport avec le contexte dans lequel elle est appliquée : faire apprendre une table de
multiplication "par l'expérience" ne parait pas très judicieux, tout comme faire apprendre des notions de relations sociales par du "par coeur".
Un point constituant un plus pour le jeu est donc la bonne
intégration des méthodes d'apprentissage dans celui-ci, car bien gérée, elles vont aider le joueur à s'immerger progressivement dans le jeu.
Généralement les phases d'apprentissage se font dans les premiers 'niveaux' du jeu, alors que la difficulté est moindre.
Les erreurs sont donc moins chèrement payées. Attention, cela n'est pas une raison pour négliger les conséquences de ces dernières.
Par exemple, dans un jeu de rôle, le joueur vient de passer une petite heure à se créer un personnage sur mesure, explorant les fonctionnalités du générateur de personnages. Le didacticiel se
déroule sur un bateau et le joueur décide de monter à la vigie, il fait une fausse manipulation et son personnage tombe sur le pont et meurt. Il serait dommage de ne pas avoir prévu une
sauvegarde automatique à la fin de la création du personnage...
Autre exemple avec un jeu disposant d'un ladder, le joueur fait des essais, apportant peu d'importance à ses scores... Quelle déception quand il découvrira que ces 'essais' ont été
comptabilisés et pénaliseront sont classement.
II- Les méthodes d'apprentissage
Les principales méthodes répertoriées sont donc les suivantes :
Apprentissage par imitation :
Il s'agit de montrer au joueur ce qu'il doit faire pour
quel résultat : le jeu manipule les périphériques d'entrées (clavier, pad, souris) à la place du joueur pour lui montrer comment opérer. Idéalement, pour le clavier ou le pad, le jouer aura à
l'écran une représentation de ces derniers et pourra visualiser les combinaisons de touches / boutons utilisées.
Apprentissage par essais et erreurs :
Le joueur se crée sa propre expérience.
Généralement, cela se fait dans les premiers niveaux du jeu où le joueur est relativement 'Protégé' et peu donc tester à loisir les fonctionnalités du jeu sans grand risque. Il s'agira aussi
d'orienter le joueur en restreignant ses possibilités au domaine de connaissances que l'on souhaite lui faire acquérir.
Apprentissage par explication :
Il s'agit ni plus ni moins que d'expliquer au joueur comment procéder. Cette méthode est généralement présente sous la
forme d'une aide, mais on la retrouve aussi parfois disponible sous la forme de livres, parchemins ou autres supports de lecture, ou encore sous la forme de dialogues avec des PNJ. Les
info-bulles font aussi parties de l'apprentissage par explication.
Apprentissage par répétition :
Le joueur est invité à répéter de multiples fois la
même action jusqu'à la maîtriser suffisamment. Cette méthode apparaît souvent sous la forme d'un mode de jeu de type 'Entraînement' et est principalement utilisée dans les jeux de baston pour
l'apprentissage de combinaisons de boutons.
Apprentissage combiné :
Il ne s'agit pas à proprement parler d'une méthode. L'idée est
simplement de combiner les méthodes listées ci-dessus afin d'optimiser l'apprentissage.
Le schéma
suivant montre les principales combinaisons rencontrées.
Afin de compléter et d'illustrer mon précédent article, vous trouverez ci-dessous quelques chiffres concernant les performances du A*.
Avant tout, il faut préciser quelques points :
- Ce qui intéresse dans les chiffres que je donne, c'est plus leur variation que leur valeur.
- L'algorithme que j'ai utilisé est un A star 'pur' : aucune heuristique n'a été mise en place.
- Le langage de programmation que j'ai utilisé n'est pas fait pour ce genre de travail, les temps donnés pourront donc paraître exagérés.
- J'ai utilisé le modèle suivant pour la recherche : la présence de la croix m'a surtout servi à valider le chemin trouvé, allant du point rouge au point bleu.
Les résultats :
|
Dimension |
Nombre de cases |
Temps de recherche |
Cases testées |
Longueur du chemin |
| 10x10 | 100 | 0.015 | 60 |
15 |
| 20x20 | 400 | 0.37 | 245 | 30 |
| 30x30 | 900 | 1.84 | 550 | 40 |
| 50x50 | 2500 | 18 | 1600 | 75 |
Le nombre de cases testées a été grossièrement arrondi, il est là avant tout pour donner un ordre de grandeur et dépend de la position de la croix sur la grille.
Quelle conclusion en tirer ?
Sans une heuristique efficace, donc adaptée à chaque cas, l'A* est rapidement gourmand en temps.
L'exemple donné reste toutefois assez extrême, puisqu'il n'y a, au final, que peu de chemins en concurrence, et beaucoup d'espace libre, ce qui accentue notablement la lourdeur de la
recherche.
Bien souvent, il est nécessaire lorsque l'on réalise un jeu, de mettre en place un algorithme de pathfinding. Le plus connu d'entre eux est probablement le A* (prononcer ''A' star').
1- Principes
Les prérequis indispensables à l'utilisation de cet algorithme sont :
- de formaliser la zone à parcourir sous la forme d'un réseau. Ce dernier peut se présenter sous la forme d'une grille, mais ce n'est pas une obligation. Il va de soit que
chaque noeud de ce réseau doit permettre de trouver les noeuds avec lesquels il a un lien.
- connaître le noeud de départ et le noeud d'arrivée.
On utilisera aussi deux listes :
- une liste 'ouverte' : qui contiendra tous les noeuds accessibles depuis le noeud de départ.
- une liste 'fermée' : qui contiendra la liste des tous les noeuds qui ont déjà été étudiés.
Chaque liste contiendra : l'identifiant du noeud, l'identifiant du noeud précédent, un coût.
Le déroulement est très simple :
- En partant du noeud de départ, on identifie les noeuds voisins.
- Pour chaque noeud voisin, on calcule un coût constitué du coût pour atteindre le noeud précédent, plus le coût pour aller du noeud précédent à ce noeud.
- On passe le noeud de départ dans la liste des noeuds 'fermés', et ses noeuds voisins dans la liste des noeuds 'ouverts'.
- Ensuite, dans la liste ouverte, on étudiera le noeud ayant le coût le plus faible . Il faudra aller chercher ses noeuds voisins. Si le noeud voisin est dans la liste 'fermée', il a déjà
été étudié et est donc ignoré : le nouveau coût calculé sera forcément au moins égal, voir supérieur.
Sinon, il faudra en calculer le coût associé :
Si le noeud voisin est dans la liste 'ouverte', et que le nouveau coût calculé est inférieur au dernier enregistré, on met à jour la liste avec le nouveau coût, et on change l'identifiant de son
noeud précédent pour le noeud étudié.
Si le noeud voisin est dans la liste 'ouverte', mais que le nouveau coût calculé est supérieur au dernier enregistré, on ne change rien.
Si le noeud voisin n'est dans aucune des listes, on le passe dans la liste ouverte.
On arrête la recherche lorsque le noeud de destination est trouvé, il est alors à son tour passé dans la liste 'fermée', ou qu'il n'y a plus de noeud dans la liste ouverte. Dans ce dernier cas,
cela signifie qu'il n'y a pas de chemin permettant d'aller du noeud de départ au noeud d'arrivée.
Au final, s'il existe un chemin, on obtient une liste chaînée des différents noeuds à parcourir.
L'A star permet de toujours trouver le chemin le plus court en terme de coûts.
2- Calcul des coûts
Le coût pour passer d'un noeud à un autre n'est pas forcément une constante unique à tous les noeuds : il pourra varier en fonction de différents critères.
Dans un RTS, s'agissant de parcourir une carte, on trouvera généralement une variation du coût en fonction du terrain à parcourir, de la météo, de la nature de l'unité,.... Par ailleurs, il peut
aussi être pertinent de tenir compte de facteurs comme la dangerosité de certaines zones ou leur éloignement.
3- Optimisation de la recherche
3.1 Heuristique et A star
A la base, nous avons vu que la liste ouverte se parcourait dans l'ordre croissant des coûts. Le but va être de prendre en compte d'autres critères que le simple coût du chemin parcouru pour
choisir la séquence des noeuds à étudier dans la liste 'ouverte', afin de privilégier un chemin 'probablement' plus court.
Il faudra toutefois être particulièrement attentif au fonctionnement de la liste fermée : ne doivent se trouver dans cette liste que les noeuds dont le coût est définitivement acquis. Dans le cas
contraire, il faudrait non seulement mettre à jour ce noeud, mais aussi recalculer tous les coûts de tous les noeuds dont le chemin passerait par un noeud ayant fait l'objet d'une réévaluation de
son coût suite à ce simple changement.
Outre ce point, il y a de fortes probabilités pour qu'une heuristique mise en place sur un algorithme comme le A star ne fournisse plus systématiquement le chemin le plus court, mais un chemin
parmi d'autres.
3.2 Maillage
Un des inconvénients de A star est que sur des réseaux de grandes tailles, et plus particulièrement des cartes, son temps d'exécution va augmenter de façon disproportionnée.
Une autre méthode pour optimiser la recherche, s'appliquant plus particulièrement à la recherche de chemin sur une carte, consiste donc à calculer à l'avance les coût relatifs
à des points particuliers de la carte.
L'algorithme sera alors utilisé trois fois successivement : une première fois pour estimer le trajet du point de départ vers un premier noeud particulier, une deuxième pour aller
du point de destination vers un second point particulier, et une troisième fois pour rejoindre les deux points particuliers.
Ci dessous, en jaune, la zone approximativement étudiée avec le A star standard : on remarque que la recherche couvre une grande partie de la carte, et que le chemin trouvé est très optimisé.
A l'opposé, avec le maillage, la surface de recherche est beaucoup plus réduite. D'autre part, le maillage permet d'élargir un peu le chemin trouvé si le besoin s'en fait sentir.
Là encore, il faut savoir adapter en fonction de ses besoins.
3.3 Perfection et réalité
Comme indiqué, l'A star permet de toujours trouver le chemin le plus court en terme de coût. Or, dans la réalité, lorsque l'on cherche son chemin, on ne trouve que très rarement le parcourt
optimal au premier essai : ainsi conçu, cet algorithme ne permet d'avoir cette sensation d'hésitation dans la recherche.
Il peut donc être intéressant, par exemple, de diviser la recherche en plusieurs étapes successives en fonction de l'éloignement du point d'arrivée ou de la vision du réseau qu'en a l'objet
cherchant son chemin. Une illustration simple de cette problématique est la gestion d'un brouillard de guerre : il parait inconcevable de rester sur une solution où une unité irait directement au
but dans une zone non découverte, en évitant des troupes ennemies qu'elle ne voit pas et en contournant des obstacles invisibles.
2.2.6 Description des modes de jeu
Les éléments de bases et leur gestion bien définie, il faut ensuite décrire avec autant de précision quels seront les objectifs à remplir en terme de jeu, et comment ses objectifs seront gérés
par le jeu.
Donc, par mode de jeu, il faudra lister :
- L'intérêt du mode de jeu, à titre
d'introduction : avant toute chose, il est nécessaire de préciser pourquoi le mode de jeu a été retenu.
Par exemple, il peut apporter des choses à différents niveaux :
Dévoiler un élément du scénario : ce sera, par exemple le mode 'Histoire' d'un jeu de
baston.
Proposer un challenge particulier : comme les modes en temps limité.
Etablir un ladder avec des
conditions de jeu identiques pour tous les joueurs.
- Les objectifs à remplir : il ne s'agit pas de faire tout le level design du
jeu, mais de préciser les 'conditions de victoire' pour le joueur. Ces conditions doivent être le plus clairement défini : rappelez-vous quelles seront ensuite à exploiter par les programmeurs et
level designers.
Par exemple, et succinctement :
Vaincre successivement 12 adversaires sans subir une défaite.
Trouver un objet particulier qui sera indiquer dans un cadre en haut à droite de l'écran. L'objet sera tirer au sort parmi ceux du
disponibles dans le niveau.
Marquer au moins Niveau*5000 points en un
moins de 20-Niveau minutes.
- Toutes les règles spécifiques du mode de jeu : point important, il faut indiquer clairement toutes les règles spécifiques qui seront à appliquer. Comme pour le point précédent,
ces éléments seront ensuite repris par d'autres membres de l'équipe, il faut donc être très précis.
Par exemple :
Entre deux combats, le joueur récupère 20-niveau % de points de vie.
Le niveau ne comportera pas les bonus spéciaux suivants : invulnérabilité, invisibilité.