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.