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é
	}
}

Les lucioles aident Charles, le héros, dans sa quête pour briser le sort jeté par leur reine, Eris. Elles peuvent être contrôlées par le joueur en jeu et ont des pouvoirs variés. J'ai travaillé sur leur design graphique.

Eris

Eris est la reine, elle suit Charles en permanence pour lui donner une leçon de vie. Le garçon est puni pour avoir détruit sa paisible cité. Elle est utile au joueur car elle donne des conseils à l'enfant. Je l'ai dessinée après les autres.

Dès le début de Contre-Jour, nous commencions à réfléchir au logo du jeu. Finalement, après quelques propositions, j'ai eu le plaisir d'en être l'auteur.

Le logo

Le logo devait démontrer d'un seul coup d'oeil que :

• Contre-Jour est un jeu vidéo ;
• Il s'agit d'un jeu sur l'ombre et la lumière ;
• L'histoire se déroule au début du XXéme siècle à Paris.

Texture

Je voulais que les lettres et la décoration soient en fer forgé. Après quelques essais, j'ai trouvé une technique simple pour créer cet effet directement à partir des filtres de Photoshop.

J'ai ensuite dessiné l'ampoule et fini par le halo.