Concept

At the begining it was said I had to work on something epic but trying to avoid adding features because of the deadline.

I started to think about a way to design a generic combat. The best way was to use the tap and sliding quick time events and also, because in this part you are fighting a boss I wanted the player to feel it this way.

So I decided to create this kind of patterns a boss can have and added a healthbar on both character to make a comparison and add tense for the player. To sum up the design, the fight uses randomly chosen sequences of QTEs with different ratio. At first, Teal'c will try to hit his opponent. If he succeed, Khufu looses some health, in the other case, the boss just block and try to counterattack, giving the player a last chance to acheive another QTE to save his character from the death.

Anyway, if he is alive, another sequence is chosen. Maybe Khufu will attack Teal'c and the player will have to block or will see the healthbar decreasing. In anoher case, maybe he will have to make several combos. If he fails Teal'c takes one more hit.

A second part

After, I added a second combat part, like an evolution of the boss. When the player reachs the bottom of Khufu's healthbar, the second sequence starts with Teal'c losing his weapon. In this position the boss becomes harder but the sequence is more like a cinematic showing a more epic combat helping the player feeling the tense of it.

Designing the moves

With the help of other colleagues we made some captures of the most important moves to give the most information we can to the animator. After defining more content, we recorded some videos.

As an adventure game, Contre-Jour has a storyline. So, it was necessary to save the player progress in the game. As well, the game is organized in little levels linked together with some entrances/exits. When the hero moves to another level, the progress is saved in a binary file.

The save concerns different data:

• The player data: coins collected, current level, current entrance in the level...
• The data concerning all the levels: the position of the pushable objects, the coins and items taken, the doors opened, the switches positions,...
• The savable parameters concerning the GSE: To play events only once, ...

To do this, I used a binary file with a specific nomenclature. This kind of file is sequentially organized. A playhead reads or writes the data and moves forward.

The savegame nomenclature

In the main flow

• The player data at first
• The byte number of the whole flow concerning the levels

In the levels flow

The flow contains the total of levels and a list with each level data as items: the number of bytes and each level flow corresponding.

In each level flow

Each flow contains the number of the objects saved and the sequential list of the data for each one. An object data is made of an identifier and a specific flow. (For a pushable crate, we keep the position for example). GSE boxes are handled like other objects but we save the parameters instead.

On the code side

Originally, I used two kinds of basic C# functions.

//Create a file or open the existing one and delete the content
BinaryWriter binWriter = new BinaryWriter(File.Open("myfile.txt",FileMode.Create));
//Write data in the file
binWriter.Write("CJSaveGame");//a string
binWriter.Write(10);//an int
binWriter.Write(10.5f);//a float
binWriter.Write(true);//a bool
//etc.
binWriter.Close();//close the file

if(File.Exists("myfile.txt")){//Verify the file existence
	//Open the file
	BinaryReader binReader = new BinaryReader(File.Open("myfile.txt" , FileMode.Open));
	try{
		if(binReader.PeekChar() != -1)//If the file isn't empty
		{
			//ReadString: read bytes and move the readhead
			string str = binReader.ReadString();//a string
			int integer = binReader.ReadInt32();//an int
			float number = binReader.ReadSingle();//a float
			bool boolean = binReader.ReadBoolean();//a bool
		}
	}
	finally{
		binReader.Close();//close the file
	}
}

In Contre-Jour, the levels are short and the player ends them quickly. In order to gain time in loading the scenes, I created a level streaming manager.

At the game start, the manager loads the current level where the player characeter is and lanches the game. Next, the level is playable directly but during the game, the manager continues and load the levels directly linked to the one we are playing. For example, when the hero is in the first map ( the red point), the second level is preloaded.

If the level 2 is loaded when the player finishes the first then we go to that level without any loading screen. Arrived in this new place the third one is loading and so on. The first map stays loaded because it's directly linked. We can go back without waiting.

On the code side

The level streaming manager uses a list of all the levels. Each level item is made of a scene to load and a boolean list.

• isLoading: Is the level currently loading
• isDataLoaded: Is the level loaded

[System.Serializable]
public class levelsList{
	public string name;//level identifier
	public string description;
	
	[System.NonSerialized]
	public bool isLoading = false;//Is the level loading
	[System.NonSerialized]
	public bool isDataLoaded = false;//Is the level loaded 
}

public class GameManager : MonoBehaviour {	
	public LevelsListElement[] levelsList;//List of levels
	//...
}

Unity3D contains a simple function to load a scene in asynchronous mode.

private IEnumerator streamLevelCoroutine(int level){
	if(!levelsList[level].isLoading && !levelsList[level].isDataLoaded){//We load the level only if needed
		//LoadLevelAdditiveAsync: Stream the loading of a scene.
		yield return Application.LoadLevelAdditiveAsync(levelsList[level].name);
		levelsList[level].isDataLoaded = true;//The level is loaded and available
		
		levelsList[level].isLoading = false;//Loading ends
	}
}