Upload
others
View
0
Download
0
Embed Size (px)
Citation preview
Corentin Pacaud Boehm ENJMIN 2020
Spécialisation Programmation
Out of The Loop
Sujet : La Jetée (1962) – Chris Marker
2
Table des matières
Partie Commune .......................................................................................................................................3
Synopsis .............................................................................................................................................. 4
Analyse ................................................................................................................................................ 4
Amorce .................................................................................................................................................5
Concept du jeu ...................................................................................................................................5
Accessibilité ........................................................................................................................................6
La proposition de jeu .......................................................................................................................6
Références...........................................................................................................................................6
Partie Spécifique.......................................................................................................................................8
CV et Portfolio .......................................................................................................................................9
CV ............................................................................................................................................................9
Portfolio ............................................................................................................................................. 10
Parcours programmation ................................................................................................................ 14
Présentation du jeu ........................................................................................................................ 14
Introduction ...................................................................................................................................... 15
La génération aléatoire ................................................................................................................ 15
La création de musiques sur mesure ....................................................................................... 16
La génération par analyse de la musique .............................................................................. 18
En conclusion .................................................................................................................................. 20
3
Partie Commune
4
Synopsis
L’histoire débute alors que Paris est détruite suite à la Troisième Guerre mondiale. La
surface est inhabitable dans sa grande majorité à cause des radiations. Des survivants,
autoproclamés vainqueurs, se terrent dans les souterrains de Chaillot et décident de faire
subir des expériences à des prisonniers. Ces expériences ont pour but de faire voyager les
sujets à travers le temps pour quémander des ressources dans le futur et dans le passé
afin de venir en aide au présent. Sur ce constat, nous suivons un prisonnier, ancien
combattant, à travers les expériences qu’il subit, ses rencontres à travers le temps et ses
nombreux voyages temporels.
Analyse
« La Jetée » est un film expérimental réalisé par Chris Marker, sorti en 1962. Le film est
entièrement en noir et blanc et n’est composé que de photographies (hormis pour un
plan). Le choix du réalisateur de n’utiliser aucun plan vidéo peut s’expliquer par choix en
imposant le rythme du film non par les images filmés mais par les sons, la musique et le
montage. On remarquera que Chris Marker arrive à créer des moments forts tels que la
course du protagoniste vers sa mort à la fin du court-métrage ou encore en montrant sa
douleur durant les expérimentations simplement en montrant une succession d’images
avec un rythme plus soutenu.
Le film ne nous donnera aucun dialogue. Les seules voix que l’on peut entendre dans le
film seront celles du narrateur, une voix monocorde et posée et celles des responsables
des expériences, plus rapides et oppressantes sous forme de chuchotements. Il y a une
grande différence de rythme entre les passages où l’on entend le narrateur et ceux où l’on
entend les responsables d’expériences. D’un côté, le narrateur nous présente l’histoire
d’un homme hors du temps n’ayant aucune priorité et de l’autre côté, nous pouvons
entendre les voix des responsables d’expériences, vivant exclusivement dans le présent
et dans l’urgence.
Le film emprunte à plusieurs genres cinématographiques. Le réalisateur se plaît à les
mélanger à travers toute la durée du court-métrage. Dans la première partie, c’est à la
façon d’un documentaire qu’est présenté ce qu’il reste de la civilisation avec des plans de
Paris détruite et le narrateur racontant le déroulement de la troisième guerre mondiale
et de ses répercussions. Par la suite, les films de romance sont représentés à travers
l’histoire d’amour que va vivre le protagoniste au travers des scènes dans le parc et dans
le musée. Enfin, le film est ponctué régulièrement d’interludes qui peuvent s’apparenter
aux films de science-fiction post-apocalyptiques avec les expériences que subit le
protagoniste, les visions du futur et les plans dans les souterrains.
5
Là où le film se démarque, c’est par la structure narrative. Le film débute par une scène
sur la grande Jetée d’Orly où un homme se fait tuer sous les yeux d’un enfant, qui sera
marqué à vie. Il est dit de cette scène par le narrateur que le protagoniste « ne devait
comprendre que beaucoup plus tard la signification ». Cette phrase qui en apparence ne
devrait concerner que lui, nous est en réalité aussi adressée. Le réalisateur s’adresse ici
directement aux spectateurs et nous présente le dénouement, mais également le
commencement de l’histoire. Car c’est bien par cette même scène que se finit le film, sur
la Jetée d’Orly. Si le protagoniste meurt sur cette Jetée, est-il alors condamné à revivre ce
moment ?
Amorce
Une faille dans la boucle temporelle a permis au protagoniste de se souvenir de ses vies
passées. Contacté par un groupe nommé « l’Agence » se disant responsables de la faille, le
protagoniste cherche à s’échapper des souterrains où on le retient. En utilisant son passé
militaire et toutes les expériences qu’il a vécues, il va devoir tromper la vigilance de ses
geôliers et traverser les souterrains afin d’en apprendre plus sur ce groupe et son objectif.
Concept du jeu
Le jeu va se présenter sous la forme d’un jeu d’aventure/infiltration à la troisième
personne. Il sera découpé en une succession de niveaux à travers les souterrains de
Chaillot pour enfin sortir à la surface de Paris.
Le joueur devra utiliser l’environnement à son avantage pour lui permettre de s’échapper.
Il devra se déplacer furtivement pour ne pas attirer l’attention des gardes. D’autre part, il
pourra s’aider des objets disposés dans l’environnement ou des autres prisonniers pour
tromper la vigilance des gardes et lui permettre de s’échapper.
Le joueur se rendra très vite compte cependant que le temps est malléable. Ses nouveaux
alliés de l’Agence offrent la possibilité au protagoniste de revenir un court laps de temps
dans le passé, à un moment où il était en sécurité pour l’aider dans son évasion. Cela lui
permettra d’en apprendre plus sur les passages qu’il va traverser, sur la position des
gardes, etc… Cette particularité lui permettra, qui sait, de s’extirper de situations
malencontreuses.
6
Accessibilité
Le jeu sera disponible sur PC & Consoles et sera accessible à tous les amateurs de jeux
d’infiltration. Le jeu cible majoritairement les personnes de plus de 12 ans (en raison du
thème abordé et des images présentes en jeu). Le jeu se joue au clavier et à la souris ou à
la manette.
La proposition de jeu
En ayant passé un certain temps à réfléchir comment exploiter au mieux l’histoire du film
et ses particularités, j’ai finalement décidé de me baser sur le point qui à mon sens est non
seulement le plus intéressant à traiter dans un jeu mais également essentiel dans la
narration du film : la manipulation du temps.
Dans cette trame narrative, le protagoniste n’est plus simple spectateur de sa propre vie
mais acteur. Il pourra manipuler le temps grâce à cette mécanique de retour dans le passé
au lieu d’en être victime. Cette mécanique pourra non seulement servir la narration mais
aussi le gameplay en ajoutant une dimension d’apprentissage bien plus importante que
dans les jeux du même genre.
À travers les décors et l’environnement, nous pourrons explorer l’univers de Chris Marker
en profondeur (Paris détruite, souterrains servant aux expérience des « vainqueurs »)
mais aussi à travers l’aspect visuel du jeu (grâce au choix de couleur, à la lumière et aux
ombres, etc…).
Références
▷ Univers narratif : Time Stories est un jeu de société créé par la société Space Cowbows.
Que ce soit par le principe de jeu (voyage dans le passé avec nombre de run et durée
limitée) ou par la narration (plusieurs agences temporelle et factions renégates), ce jeu
est une des inspirations importantes du jeu.
7
▷ Gameplay et level design: Styx : Master of Shadows est l’inspiration principale pour ce
qui et des déplacements et des interactions avec l’environnement (escalader, éteindre les
torches, attirer les gardes, etc …). Nous pouvons également noter A Plague Tale : Innocence
qui est sorti plus récemment et qui est plus proche en ce qui concerne les capacités du
joueur ; le joueur sera assez limité dans ses actions et le but n’est pas d’éliminer tous ses
adversaires mais de les esquiver ou d’utiliser l’environnement pour traverser les endroits
inaccessibles. Pour ce qui est de la navigation dans les niveaux, le level design est inspiré
des séries de jeux Deus Ex et Dishonored avec les nombreux passages possibles qui sont
offert aux joueurs, les passages dans des couloirs étroits, etc…
▷ Décors et ambiance : Dans le contexte d’un univers post-apocalyptique, les souterrains
sont des décors assez répandus dans de nombreuses œuvres tels que ceux décrits dans
les livres Metro 2033 (et dans son adaptation en jeu vidéo) ou Silo. Ceux-ci se prêtent
parfaitement bien au type d’ambiance que nous cherchons à représenter, c’est-à-dire une
ambiance sombre et oppressante pour le joueur.
▷ Mécanique de retour vers le passé : L’idée de pouvoir revenir dans le passé provient
de Prince of Persia : Les Sables du Temps. La mécanique permettait au personnage
principal de revenir pendant un cours laps de temps dans le passé. Elle a cependant été
adaptée pour coller au jeu d’infiltration sans le rendre trop facile (retour dans le temps à
un point de passage et non pas de quelques secondes).
▷ Univers visuel : L’aspect visuel du jeu s’inspire de plusieurs titres tels que Limbo pour
la palette de couleurs, XIII pour l’aspect cel-shading mais c’est principalement le film
français Renaissance qui correspond le mieux au visuel que je souhaite représenter.
8
Partie Spécifique
9
CV et Portfolio
CV
10
Portfolio
#1 –Développent de jeux de tirs :
Étant fan de jeux Shoot'em up/Bullet hell, j’ai commencé à expérimenter tout d’abord sur
Unity (en C#) avec un jeu très peu original où le but était de survivre à des vagues de
zombies. J’ai pu « terminer » le jeu en un mois durant l’été 2018. J’ai ajouté des guillemets
car ce jeu est resté à l’état de prototype, certes jouable, mais peu amusant et ayant peu
d’intérêt. L’idée derrière ce jeu n’était pas tant de créer un jeu complet, beau et amusant,
mais c’était surtout pour moi un moyen d’expérimenter et de m’améliorer sur Unity et sur
beaucoup d’aspects techniques nécessaires pour la création d’un tel jeu.
J’ai donc eu l’occasion d’aborder les IA (avec un algorithme de pathfinding A*), j’ai pu
manipuler l’UI avec une interface simple, j’ai utilisé l’audio (dommages occasionnés aux
zombies, les bruits de tirs, etc…) et j’ai créé des animations pour les ennemis et le joueur.
J’ai également créé un système d’inventaire, un système de vague et de spawn,
d’endurance, de munitions, etc…
(https://corentinpb.itch.io/zombie-defense)
Par la suite, j’ai décidé de laisser ce dernier projet tel quel pour me consacrer à des projets
plus originaux et plus aboutis. Cependant, cette idée de travailler sur des jeux de type
Shoot'em up/Bullet hell était toujours présente et c’est pourquoi j’ai décidé de développer
un nouveau jeu en collaboration avec une autre personne toujours sur la base d’un top-
down shooter en 2D mais qui intègre des éléments de roguelike inspirés de jeux tels que
The Binding of Issac ou Just Shapes and Beats. Nous avons cette fois-ci décidé d’essayer un
nouveau moteur moins connu qu’Unity : Godot (en GDScript, un dérivé du python). Une
grande partie du développement jusqu’à maintenant a été sur les bases du jeu
(déplacements, gestion des collisions, création des premiers ennemies, etc …) car nous
avons rencontrés des problèmes sur un certain nombre de points.
https://corentinpb.itch.io/zombie-defense
11
L’un de ces points critiques auquel nous avons dû faire face a été les collisions. Nous
voulions un jeu possédant un rythme rapide et des projectiles de petites tailles ayant une
vitesse élevée. Hors, sur la grande majorité des moteurs de jeu, les collisions perdent en
précision plus la vitesse des projectiles est grande et
moins la taille des objets qui rentrent en collision est
grande (tunneling). Nous avons donc dû
expérimenter en utilisant d’abord des zones de
collision, des raycasts, plusieurs types de corps
(rigidbody, kinematic, etc …). Toujours est-il que le
projet suit son cours et reste toujours en
développement ; nous prévoyons de sortir le jeu d’ici
quelques mois.
#2 – Conception de menus et d’interfaces :
J’ai commencé récemment à travailler sur un projet de jeu nommé Twin Sticks, qui est un
jeu arcade/musical (de Janvier 2020 à aujourd’hui). Le principe du jeu était de tenir le
rythme en éliminant des notes qui arrivent sur deux fronts différents en utilisant les sticks
et les gâchettes d’une manette. Ce jeu ne se jouant qu’à la manette, il a donc été nécessaire
de créer des menus ergonomiques et adaptés aux contrôles manette.
(https://www.deviantart.com/corentinpb/gallery/72091068/twin-sticks)
Un des projets de jeu sur lesquels j’ai travaillé durant mes années en IUT informatique a
été le projet Lightbot (au cours de l’année 2017). J’ai pu créer deux interfaces ayant deux
thèmes bien distincts (clairs/sombres). Ces deux thèmes ont été utilisés au cours d’un
projet de la formation par deux groupes différents.
(https://www.deviantart.com/corentinpb/gallery/63089083/lightbot-project-v0)
(https://www.deviantart.com/corentinpb/gallery/63089147/lightbot-project-v1)
https://www.deviantart.com/corentinpb/gallery/72091068/twin-stickshttps://www.deviantart.com/corentinpb/gallery/63089083/lightbot-project-v0https://www.deviantart.com/corentinpb/gallery/63089147/lightbot-project-v1
12
Un des autres projets sur lesquels j’ai pu travailler à l’IUT était une application de gestion de stocks
de plusieurs entrepôts basés sur Java avec une base de données MySQL MariaDB et des interfaces
construites à partir de SceneBuilder. J’ai été en charge de la construction d’un certain nombre de
fonctionnalités et d’agencements sur ces interfaces.
(https://gitlab.com/IUT-Informatique-CPB/Gestion_Entrepots_Stocks)
#3 – Projets issus de mes expériences professionnelles :
J’ai pu réaliser plusieurs projets au cours de mon stage et de mon année d’alternance et je
souhaite ici en présenter deux. Le premier projet concernait la création d’un agent
conversationnel durant mon stage dans l’entreprise Metapolis. Cet agent conversationnel
a été créé sous l’outil Tock créé par la SNCF, qui fonctionne sous JVM avec Kotlin comme
langage de référence.
En plus d’offrir une plus grande liberté sur les connecteurs (interfaces sur lesquels le bot
sera présent telles que Messenger, Google Assistant,
etc …), l’outil était totalement libre et nous étions en
contact direct avec les développeurs de l’outil. Celui-
ci fonctionne sur le principe des intentions et des
entités (détecter dans une phrase quelles sont les
intentions de l’utilisateur ainsi que les informations
qu’il a donné grâce à un module NLP).
Ce chatbot nous a été utile pour évaluer les possibilités qu’offraient Tock par rapport à
l’outil que nous utilisions alors à l’époque Recast.AI. Il nous a également permis de faire
un premier essai sur un chatbot qui sera alors utilisé par la suite par la mairie de Paris
pour expliquer la réforme sur le stationnement à Paris en début 2018.
https://gitlab.com/IUT-Informatique-CPB/Gestion_Entrepots_Stocks
13
Le deuxième projet que je souhaite aborder est un projet initié durant mon année
d’alternance à la SNCF en 2019. Ce projet concernait la création d’un outil d’aide à la
décision qui permettrait aux équipes internes de connaître les charges des trajets des TER
en Nouvelle-Aquitaine. Ce projet a été créé sur Excel (en VBA) en raison de
l’environnement interne quasiment exclusivement sur office.
Pour fonctionner, l’outil se base sur deux sources qui sont les comptages (nombre de
personnes présentes dans chaque trajet sur une période donnée) et les roulements (la
composition de chaque TER pour chaque trajet sur une période donnée) qui seront
croisés afin d’obtenir l’occupation de chaque trajet sur une période et à chaque arrêt. J’ai
aussi pu développer avec cet outil un module de statistiques permettant d’obtenir les
occurrences de chaque type d’occupation pour une période donnée.
Aujourd’hui, l’outil est utilisé en production afin de permettre aux équipes internes de
dimensionner les trains correctement aux trajets les plus surchargés ou même aux trajets
les moins chargés, il permet également de rationaliser les offres, faire du ciblage
publicitaire, etc ...
14
Parcours programmation
Présentation du jeu
Avant de vous présenter la problématique et d’entrer dans les détails, je vais d’abord vous
présenter le jeu sur lequel se base cette problématique. Twin Sticks est un projet donc j’ai
brièvement parlé dans la partie portfolio. C’est un jeu d’arcade musical que j’ai commencé
en début d’année 2020 où le but est de tenir pendant toute la durée d’une musique
sélectionnée par l’utilisateur en éliminant des notes qui apparaissent sur l’écran.
Comme vous pouvez le voir sur l’image ci-dessus, l’écran se divise en deux parties à
gauche et à droite tandis qu’en dessous, nous avons des éléments d’interface. Chacun des
deux cercles sont divisés en 6 parties avec une ligne au centre de chaque zone. Au milieu
de chaque cercle se trouve des « points » (cercle noirs avec une barre blanche) qui sont
chacun contrôlés par les deux sticks d’une manette. Ces points ne peuvent se déplacer
qu’autour de l’hexagone central et si le joueur ne touche pas au stick, le point retournera
au centre.
Des « notes » (les cercles noirs aux contours gris) vont apparaitre au bout du cercle et se
déplaceront jusqu’au centre (hexagone noir). Le joueur doit éliminer les notes qui
apparaissent avant qu’elles atteignent le centre en appuyant sur les gâchettes
correspondant au cercle où se situe la note à éliminer. Pour que la note soit éliminée, le
point du joueur doit se situer sur la même zone que la note. Dans le cas où la note est
éliminée, un cercle blanc va recouvrir la note jusqu’à ce qu’elle disparaisse.
À chaque note éliminée, le joueur va augmenter son score (au milieu en bas) et son score
augmentera de plus en plus pour chaque note consécutive éliminée (en bas à gauche). Un
score de précision est affiché en bas à droite et enfin la barre grise qui se remplie en bas
de l’écran correspond à l’avancement de la musique.
15
Introduction
La problématique que nous allons traiter dans ce dossier est la suivante : « Créer des
niveaux intéressants sur un jeu de rythme ». Nous aborderons les possibilités en ce qui
concerne la génération de niveau, les problèmes que j’ai pu rencontrer durant le
développement et enfin j’argumenterai les choix que j’ai fait.
La génération aléatoire
Pour générer des niveaux, il aurait été facile de faire apparaître de façon aléatoire les
notes sur l’une des 6 zones de chaque cercle. C’est d’ailleurs ce qui est actuellement en
place afin de pouvoir effectuer des tests sur le fonctionnement des systèmes du jeu
(destruction de notes, fin de musique, score, etc…). Les notes apparaissent sur une des 6
zones à un taux constant (toutes les 0.x secondes) du début jusqu’à la fin de la musique.
Or, bien que cette solution puisse sembler viable à première vue, la génération aléatoire
manque de profondeur pour le joueur. D’une part le taux d’apparition des notes étant
constant, cela rend le jeu assez plat, prévisible et très peu dynamique. L’intérêt du jeu s’en
trouve amoindri et l’aspect rythmique du titre est peu présent. Cela pourrait être réglé en
ajoutant un taux d’apparition variable et en ajustant la vitesse des notes pour rendre le
jeu plus dynamique et moins plat mais comment savoir quand accélérer ou réduire la
cadence d’apparition et la vitesse des notes ? En utilisant encore une fois l’aléatoire, nous
risquerions d’accélérer la vitesse à un moment « creux » de la musique ou tout le contraire,
de réduire la vitesse à un moment important et cela ne règle toujours pas le côté
rythmique (voir dégrade encore l’expérience de ce côté-là).
La génération aléatoire pose donc de nombreux soucis et notre intérêt se porte alors vers
une autre méthode : la création de musiques « à la main ».
16
La création de musiques sur mesure
La seconde méthode dont nous allons parler dans ce dossier est celle de la création de
musiques sur mesure. Elle résout de nombreux soucis présents dans la génération
aléatoire mais comme nous allons le voir ici, elle apporte de nombreux problèmes
également.
Cette méthode consiste comme son nom l’indique à créer des niveaux sur mesure pour
chaque musique proposée dans le jeu. Cela nous permet effectivement de répondre à
notre problématique, car elle nous permet bien de créer des niveaux intéressants et
surtout spécialement fait pour une musique. Nous pouvons donc faire apparaître les notes
de façon parfaitement synchronisée avec la musique, et nous pouvons même ajouter des
effets visuels personnalisés pour chaque musique pour rendre les niveaux encore
meilleurs. Le jeu se rapprocherait alors d’un jeu tel que Just Shapes & Beats dans l’idée où
chaque niveau serait parfaitement adapté à la musique joué pendant le niveau.
Cependant, cette solution apporte son lot de contraintes non négligeables en ce qui
concerne le développement et les choix de thèmes :
- La création de niveaux personnalisés est complexe car cela est long. Les créer un
par un sans outils est impensable car cela demanderait un temps de
développement trop long et ça ne serait pas efficace, d’où la nécessité d’un éditeur
de niveau. Or la création d’un éditeur de niveau demande en lui-même beaucoup
de temps de développement. La création d’un niveau avec ce nouvel éditeur à
condition qu’il soit complet et ergonomique va lui-même demander du temps, ce
qui nous amène au deuxième problème.
- Même avec un éditeur de niveau, la création d’un niveau est chronophage. Il est
donc nécessaire de faire des choix au niveau des musiques qui seront présentes
dans le jeu. Cela nous oblige à sélectionner des musiques qui ne plairont pas
forcément. Le fait de créer et sélectionner nous même les musiques, prive
forcément les utilisateurs de faire le choix de jouer les musiques qu’ils préfèrent.
Cependant, il est possible de remédier à ce problème avec une solution simple mais
risquée.
17
Pour pallier à ce manque de diversité dans le choix de musique et pour en même temps
régler le souci du temps de développement, nous pouvons ajouter une dimension
communautaire. À partir du moment où un outil de création de niveau a été mis en place,
il suffit de le rendre accessible et, d’autre part, de permettre aux joueurs de charger
n’importe quelle musique créée par la communauté, pour que le jeu déborde de diversité
dans les morceaux qu’il propose. Cela permettra en plus de faire grandir la communauté
du jeu et d’apporter de la notoriété au titre. C’est ce qui s’est passé avec le jeu osu! par
exemple qui continue d’exister aujourd’hui grâce à sa communauté et à l’éditeur de niveau
réputé pour être complet et permissif.
Il existe en parallèle trois problèmes soulevés par la création communautaire. Le premier
est la modération des contenus utilisés au sein du jeu. Il peut arriver que du contenu
inapproprié se retrouve dans le jeu sous forme de niveau crée par la communauté et cela
peut retomber sur les concepteurs du jeu. Le second est la notoriété du titre. Si le jeu ne
plaît pas et que peu de personnes ne s’y intéresse, un jeu basé sur la création
communautaire sera par conséquent vide. Enfin, le troisième problème est celui des
copyrights sur les musiques utilisées. Dans le concept original du jeu, les musiques sont
chargées par l’utilisateur depuis son disque dur et le jeu génère un niveau par rapport à
la musique. La responsabilité repose donc sur la personne qui possède la musique, le jeu
exploite simplement ce que possède l’utilisateur. Cependant, dans le cas où une
plateforme communautaire est créée et où des musiques sous formes de niveaux sont
déposées, cela pose problème pour les créateurs orignaux de celle-ci.
Toutes les contraintes évoquées ci-dessus m’ont amené à m’intéresser à une troisième
méthode qui est un compromis entre la création sur mesure et la création aléatoire.
18
La génération par analyse de la musique
La troisième et dernière méthode abordée dans ce dossier est celle de la génération de
niveaux « par analyse de la musique ». Cette méthode consiste à générer des niveaux en
analysant la musique pour faire en sorte que l’apparition des notes soit coordonnée avec
le timing de la musique.
Cette méthode présente plusieurs avantages non négligeables. Nous pouvons reproduire
une création de niveau sur mesure, en faisant apparaître les notes au bon moment par
rapport à la musique. Cela nous fera gagner du temps et bien que les niveaux ne soient
pas aussi détaillés ou aussi parfaits que ceux sur mesure, la perte d’engagement que
pourrait entrainer une génération de niveau aléatoire ne sera pas présente. Les musiques
seront toutes différentes les unes des autres et dans le même temps, un autre problème
que génère la génération aléatoire est réglé. Ce problème était que si les niveaux sont
générés aléatoirement, alors il est impossible de prévoir la difficulté des niveaux en eux-
mêmes car certains patterns de générations peuvent être plus difficiles que d’autres. En
nous basant sur la musique, nous uniformisons la génération de façon à ce que les niveaux
soient générés de la même façon à chaque fois. Chaque musique aura sa propre identité
et il est inutile de passer beaucoup de temps sur chaque niveau, car une fois le système de
génération en place, celui-ci fonctionnera pour toutes les musiques quelles qu'elles soient.
La grande difficulté de cette méthode est la mise en place de ce système de génération qui
est assez complexe.
Étant donné que ce projet est fait sous Unity, je vais parler exclusivement des APIs que
propose ce moteur pour ce genre de travaux. Le projet n’est pas terminé et c’est pourquoi
je ne vais ici aborder que des pistes pour l’implémentation d’un tel système et des choix
que j’ai fait.
Les sources audio sont représentées dans Unity en tant que composant AudioSource.
Lorsque ces composants disposent d’un AudioClip (composant qui représente les fichiers
audio), il est possible de récupérer de nombreuses informations sur le fichier audio. Il
existe notamment sous Unity deux fonctions GetOutputData qui nous renvoi un tableau
contenant l’amplitude par rapport au temps, et GetSpectrumData qui nous donne
l’amplitude relative à un moment donné par rapport à une portion de la musique. Grâce à
ces deux fonctions, il est possible d’obtenir l’amplitude de la musique jouée de deux
manières différentes :
19
- Soit nous travaillons en temps réel et nous allons alors générer le niveau au fur et
à mesure que la musique est jouée. Pour cela nous allons utiliser la fonction
GetSpectrumData, qui nous permettra grâce aux informations données par la
fonction, de déterminer si ce qui est joué actuellement est un pic de la musique ou
non. Lors d’un pic, nous ferons alors apparaître une note. Et la difficulté sera
relative à la musique en elle-même. Si la musique est calme sans beaucoup de pics,
alors la musique sera plus facile et au contraire, si la musique contient de
nombreux sons et fréquences élevés, alors la musique sera plus dure.
- Soit nous traitons le fichier audio à l’avance afin d’avoir une vision précise des pics
dans la musique jouée. Cela fonctionnera alors de la même façon et nous feront
apparaître une note à chaque pic.
Ces deux manières d’appréhender la génération de niveau se valent et j’ai d’abord
commencé à implémenter un système de génération en temps réel. Or il m’est vite apparu
que la méthode en temps réel dispose d’un véritable désavantage, qui est aussi présent
dans la méthode de génération à l’avance, mais qui est plus facile de régler avec celle-ci.
Voici ce qui s’est passé lorsque l’implémentation en temps réel a été mise en place :
Comme vous pouvez le remarquer, le nombre de notes est très élevé. Trop en réalité pour
que le niveau soit faisable. Pour l’ajout dans mon jeu de cette génération de niveau, je me
suis appuyé sur une implémentation de Jesse Keogh (https://github.com/jesse-
scam/algorithmic-beat-mapping-unity). Cette implémentation permet grâce à plusieurs
paramètres d’ajuster la sensibilité à laquelle les pics seront détectés. En modifiant ces
paramètres, il est alors possible d’augmenter ou réduire ce seuil de détection. Il serait
alors possible en théorie d’ajuster ce seuil afin que la musique génère un nombre de note
acceptable. Or, deux problèmes se posent ici. Comment détecter quel seuil est adapté à la
musique jouée et comment s’assurer que ce seuil est optimal pour toutes les parties de la
musique ?
https://github.com/jesse-scam/algorithmic-beat-mapping-unityhttps://github.com/jesse-scam/algorithmic-beat-mapping-unity
20
Comme vous le savez, un bon nombre de musiques ont des temps forts et des temps plus
faibles, c’est pourquoi il serait très difficile de créer un algorithme pour ajuster ce seuil
dynamiquement au fur et à mesure que la musique se joue.
Bien que je ne puisse vous proposer que des pistes, voici la solution vers laquelle je vais
me tourner. Nous allons donc traiter la musique à l’avance et créer un algorithme
permettant, en analysant tous les « samples » (les données que l’on retrouve dans le
tableau de GetOutputData), de définir un seuil dynamique pour chaque partie de la
musique. Cela nous permettra non seulement de créer un niveau faisable, mais aussi de
créer différents niveaux de difficulté. Nous pouvons par exemple définir un certain
nombre de note pour le niveau facile, un nombre plus élevé pour le niveau moyen, etc…
L’algorithme se chargera de parcourir la musique et d’ajuster le seuil pour chaque portion
de façon à ce que le nombre de note généré corresponde à la difficulté sélectionnée par
l’utilisateur.
En conclusion
Ce sujet est très vaste et je ne pense pas que les solutions que j’ai abordées dans ce dossier
soient les seules possibles pour résoudre la problématique que j’ai proposée. Cependant,
toutes ces méthodes peuvent fonctionner suivant la taille et la nature du projet et suivant
la direction que l’on veut prendre. La génération aléatoire peut paraître simpliste et peu
intéressante, mais celle-ci peut fonctionner sur certains projets qui ne nécessitent pas
d’avoir une identité propre à chaque musique. Par ailleurs, les autres solutions proposées
ont déjà fonctionné par le passé (osu! pour la création communautaire et Just Shapes &
Beats pour la création de niveau sur mesure), et bien que je ne sois pas rentré dans les
détails, il existe de nombreux autres exemples de jeux fonctionnant sur l’analyse des
fréquences de musique tels que Beat Hazard ou encore Audiosurf.