Concept

Au départ il m'a été demandé de créer un combat épique mais en évitant d'ajouter des features supplémentaires pour rester dans les temps.

J'ai alors commencé à penser à un combat générique. La meilleure façon semblait d'utiliser les QTE de touch et de glisser et aussi, comme dans cette partie le joueur affronte un boss, je voulais que le joueur ressente le combat.

Donc, j'ai décidé de mettre en place un pattern qu'un boss peut avoir et j'ai ajouté une barre de vie sur les deux personnages pour amener la comparaison et donner plus de tension au joueur. Pour résumer le design, le combat se divise en séquences aléatoires de QTEs avec différentes pondérations. Au début, Teal'c essaiera de frapper son adversaire. S'il réussit, Khufu perd un peu de vie, dans le cas contraire, le boss bloque et essaie de contre-attaquer, donnant une ultime chance au joueur de sauver son personnage.

En bref, s'il est en vie, une autre séquence se joue. Peut-être Khufu attaquera Teal'c et le joueur devra parer au risque de perdre un peu de vie. Dans un autre cas, il pourra peut-être placer plusieurs combos. S'il échoue, Teal'c prend des dégats.

Une deuxième partie

Après, J'ai ajouté une autre partie au combat, comme une évolution du boss. Quand le joueur vide la barre de vie de Khufu, la seconde séquence commence avec Teal'c perdant son arme. Dans ce cas de figure le boss devient plus difficile mais la séquence est cette fois plus proche d'une cinématique montrant un combat plus épique, aidant à faire ressentir plus de tension au joueur.

Design des mouvements

Avec l'aide d'autres collègues nous avons pris quelques photos des mouvements pour donner le plus d'informations possibles aux animateurs. Après avoir défini le contenu, nous avons enregistré des vidéos.

En tant que jeu d'aventure, Contre-Jour propose une histoire. Donc, il était nécessaire de pouvoir sauvegarder la progression du joueur. Aussi, le jeu est organisé en petits niveaux reliés par des entrées/sorties. Quand le héros se déplace dans un autre niveau, la progression est sauvegardée dans un fichier binaire.

La sauvegarde concerne différentes informations :

• Les infos joueur : les pièces collectées, le niveau actuel, l'entrée actuelle dans le niveau... ;
• Les informations concernant tous les niveaux : les positions des objets interactifs, les pièces et objets récupérés, les portes ouvertes, la position des interrupteurs,... ;
• Les paramètres sauvegardables du GSE : Pour jouer un évènements une fois seulement...

Pour faire cela, J'ai utilisé un fichier binaire avec une nomenclature adaptée. Ce type de fichiers est organisé de manière séquentiel. Une tête de lecture lit et écrit les informations puis se déplace vers l'avant.

La nomenclature du fichier de sauvegarde

Dans le flux principal

• Les infos joueur au début ;
• Le nombre d'octets puis le flux concernant les niveaux.

Dans le flux des niveaux

Le flux contient le nombre total des niveaux et la liste des informations pour chaque niveau : le nombre d'octets et le flux du niveau correspondant.

Dans chaque flux de niveau

Chacun des flux contient le nombre d'objets sauvegardés et une liste séquentielle des informations pour chacun d'eux. Les informations d'un objet sont formées d'un identifiant et d'un flux spécifique (pour une caisse que l'on peut pousser, on conserve la position, par exemple) . Les boîtes du GSE sont gérées comme les autres objets mais on sauvegarde leurs paramètres à la place.

Côté code

A l'origine, j'ai utilisé deux types de fonctions basiques de C#.

//Créé un fichier ou ouvre le fichier existant et écraser le contenu
BinaryWriter binWriter = new BinaryWriter(File.Open("monfichier.txt",FileMode.Create));
//Ecrit des informations dans le fichier
binWriter.Write("CJSaveGame");//une chaîne: string
binWriter.Write(10);//un entier: int
binWriter.Write(10.5f);//un nombre à virgule flottante: float
binWriter.Write(true);//un booléen: bool
//etc.
binWriter.Close();//ferme le fichier

if(File.Exists("monfichier.txt")){//Vérifie l'existence du fichier
	//Ouvre le fichier
	BinaryReader binReader = new BinaryReader(File.Open("monfichier.txt" , FileMode.Open));
	try{
		if(binReader.PeekChar() != -1)//Si le fichier n'est pas vide
		{
			//ReadString: lit les octets et déplace la tête de lecture
			string str = binReader.ReadString();//une chaîne: string
			int integer = binReader.ReadInt32();//un entier: int
			float number = binReader.ReadSingle();//un nombre à virgule flottante: float
			bool boolean = binReader.ReadBoolean();//un booléen: bool
			//etc.
		}
	}
	finally{
		binReader.Close();//ferme le fichier
	}
}

Dans Contre-Jour, les niveaux sont courts et le joueur les parcourt rapidement. Pour gagner du temps dans le chargement des scènes, j'ai créer un gestionnaire de streaming des niveaux.

Au lancement du jeu, il charge le niveau courant où le personnage se situe et lance la partie. Ensuite, le niveau est jouable directement mais pendant que l'on joue, le gestionnaire continue à charger les niveaux adjacents. Par exemple, quand le héros est dans la première carte (le point rouge), le deuxième niveau est préchargé.

Si il a fini son chargement quand le joueur termine le premier niveau alors on change de carte sans aucun écran de chargement. Une fois dans ce nouveau décor, le troisième se met en chargement et ainsi de suite. La première carte reste en mémoire parce qu'elle est adjacente. On peut donc revenir sur ses pas sans attente.

Côté code

Le gestionnaire de streaming des niveaux utilise une liste de niveaux. Chaque élément de la liste contient la scène à charger et une liste de booléens.

• isLoading : Le niveau est-il en cours de chargement ;
• isDataLoaded : La carte est-elle en mémoire.

[System.Serializable]
public class levelsList{
	public string name;//identifiant du niveau
	public string description;
	
	[System.NonSerialized]
	public bool isLoading = false;//Le niveau est-il en cours de chargement
	[System.NonSerialized]
	public bool isDataLoaded = false;//Le niveau est-il chargé 
}

public class GameManager : MonoBehaviour {	
	public LevelsListElement[] levelsList;//Liste des niveaux
	//...
}

Unity3D dispose d'une fonction simple de chargement de scène en asynchrone.

private IEnumerator streamLevelCoroutine(int level){
	if(!levelsList[level].isLoading && !levelsList[level].isDataLoaded){//On lance le chargement que si nécessaire
		//LoadLevelAdditiveAsync: Stream le chargement d'une scène.
		yield return Application.LoadLevelAdditiveAsync(levelsList[level].name);
		levelsList[level].isDataLoaded = true;//Le niveau est chargé et disponible
		
		levelsList[level].isLoading = false;//Chargement terminé
	}
}