CONTENTS Collapse Project

Contents

1 Introduction 3

2 Concept and origins 5

3 Softwares 6

4 Levels 8

4.1 Components . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

4.1.1 White Cube . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

4.1.2 Grey Cube . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

4.1.3 Starting Cube . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

4.1.4 Exit Cube . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

4.1.5 Gate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

4.1.6 Lever . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

4.1.7 Button . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

4.1.8 Pressure Plate . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

4.1.9 Laser . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

4.1.10 Sensor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10

4.2 Level Mechanics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11

4.3 The event system . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13

5 Level Editor 14

5.1 Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

5.2 Event Configuration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

6 Character 19

6.1 3D Model . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

6.2 Character Logic . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

7 Worlds 21

7.1 World Mechanics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21

7.2 Navigation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

8 Gallery 24

8.1 The local gallery . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

8.2 The online gallery . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

1

CONTENTS Collapse Project

9 The Collapse API 28

9.1 General Information . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28

9.2 Users . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

9.3 Registration . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

9.4 Login . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 30

9.5 Levels Recovery . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

9.6 Interaction with the Levels . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

10 Main Menu 34

11 Cooperative Mode 36

12 Website 37

12.1 Front-end . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

12.2 Back-end . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38

13 Personal Conclusion 39

13.1 Gael de FRANCONY . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

13.2 Edward CACIOPPO . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

13.3 Valentin BERLIER . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

13.4 Emma PAYAN . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

14 Conclusion 43

2

Collapse Project

1 Introduction

During the second semester we were asked to carry out a project using the C# programming language

running on Windows. The objective of this project was to put into practice the knowledge assimilated

during the course but also to improve our personal skills.

The objective of this report is to provide an in-depth look at the realization of the project. You will

find an explanation of the project and its implementation as well as parts detailing the contributions and

experience gained by each member.

The project is called Collapse and was realized by Gael de Francony, Valentin Berlier, Edward Ca-

cioppo and Emma Payan. We are all four students in the first year of preparatory class at the EPITA

school.

The project presented in this report is a video game made with Unity. Collapse is a game of reflexion

and agility featuring a character named Pip. After falling into a dark universe, Pip must try to find the

exit through different levels.

Visually, the game features a clean and minimalist interface. This creates a calm atmosphere in which

the player is invited to concentrate. All of our graphic resources, such as 3D models as well as textures,

were specially created by us.

The game is progressive, that is to say that as the player completes the different levels, the game

introduces new concepts and levels get increasingly difficult. Our game allows the player to solve alone

a set of predefined levels. However, it also contains a cooperative mode, in which two players need to

help each other and cooperate to complete levels that would otherwise be impossible alone. Finally, the

player is invited to express his creativity through the level editor. The level editor allows him to create his

own levels. The player can also share his creations with the player community and rate the levels created

by other players. All the different aspects of the game and their implementations will be explained in the

first part of this report.

3

Collapse Project

This project is for all of us our first real teamwork experience over a long period of time. We’ll

remind that we had to face a few difficulties regarding the composition of the group. In fact, our group

has not always been composed by the current members. Indeed, although the project began with a team

of four people, two people of our group left Epita just before we could hand back the book of specifica-

tions. We were only two left, Emma and Valentin. Gael and Edward were a group of two at the time and

were working on another project. Managing such a project with only two team members was impossible,

which is why our teams joined up just before the second defense to work together on the Collapse project.

Our team has therefore had to adapt several times and the change of project that Gael and Edward had

to go through resulted in a significant period of adaptation and familiarization with the project. During

the course of the development, each of us went through the experience in a different way and that’s why

we’ll present the our individual reports at the end.

4

Collapse Project

2 Concept and origins

Collapse game is a 3D game that combines puzzle and reflection. It features a wide range of interesting

and challenging levels. The main character lives in a simple universe deep in the darkness. Lost in the

middle of this universe, he discovers and completes different levels that gradually allow him to make his

way from world to world.

Each world is full of levels to complete. The different worlds allow the player to select levels. The

levels are arranged along a path extending to the right at the end of which a portal allows the player to

access the next world. In each world, there is only one path leading directly to the exit. The other paths

deviate from the main track and provide extra levels that can be completed as a bonus.

Our game also provides an advanced creative aspect as the player has access to an in-game level ed-

itor in which he can create and edit his own levels. The player can then play his own levels. He can also

share them online with the entire community around the world right from the game. The online gallery

allows him to play levels that were created by other players. The player can also rank levels made by

other players by giving them a star if they enjoy it.

Finally our game features a cooperative mode in which the player must team up with a friend in order

to be able to finish different levels. These levels appear in a second universe and are impossible to solve

alone.

The original idea of the game comes from Valentin BERLIER. However, each member of the team

contributed to the final concept of the game by suggesting improvements of existing ideas and / or new

ideas.

5

Collapse Project

3 Softwares

The game was developed in C# with Unity. Unity is a software, or more precisely, a video game engine

for 2D and 3D. It provides a framework that allows users to easily develop cross-platform games. Unity

allows developers to choose between two languages: Unityscript (a version of javascript adapted by the

game engine) as well as C# (Microsoft’s signature language).

In order to edit the game’s scripts we used MonoDevelop and Visual Studio. Both of these soft-

wares are powerful IDEs that allow editing and debugging of C# code. We also used Git 1, a version

control system that allows us to manage changes and the evolution of our code. Finally, we hosted a re-

mote repository of the project on GitHub 2 in order to make it easy for everyone in the team to contribute.

The components of our game have all been created and designed by the members of the group. We

used the 3D software Blender 3 which allows to model and apply textures to our models. We also used

image editors such as Photoshop and Paint.NET to create textures. All the animations that are in the

game were also created with Blender 3D.

In order to write our reports, we used Google Docs to share drafts and the main ideas of the report.

Then, we used Overleaf, a collaborative tool that allows us to give the appropriate format to the report

using LATEX.

Almost all of the concepts that we had to deal with were new to us so we therefore had to do a lot

of research. We relied heavily on Unity’s official documentation and tutorials. We have also used the

MSDN documentation to broaden our knowledge in C#.

1Git is a version control software, that is to say it follows the evolution of a code repository, saves the modifications carried outon each file and is thus be able to go back in case of problem. If two people modify the same file at the same time, their changeswill be able to merge without losing information. Very powerful and recent, Git was created by Linus Torvalds, who is amongothers, the man behind Linux.

2GitHub is a platform that provides hosting services for code repositories.3Blender is a free 3D modeling, animation and rendering software, created in 1995. It has advanced modeling, 3D sculpture,

3D animation, and rendering. It also manages video editing as well as various physic simulations such as particles, rigid bodies,soft bodies and fluids.

6

Collapse Project

Finally, let us share some of the tools and libraries that we used in order to create our website. Our

website is built with the Django web framework 4 and is primarily used to manage the backend 5 of the

website. Our game relies heavily on a REST API that we built in order to let players share and rate the

leves that they can create in-game. Django, combined with the django rest framework (or DRF for short)

made it really easy to build a fast and secure API 6 adapted to our needs.

The reason why we decided to create a Django application instead of something else in another

framework or language is primarily because python is very readable and powerful language. It’s not

hard to pick up and all of us already know at least the basics since our algorithm classes are taught with

python. Other interesting advantages of using python and Django over anything else in this situation

includes the overall quality of the application, the speed of development, the security of the final website

as well as the ease of maintenance over time.

4A framework designates in computer programming a set of tools and software components on the basis of a software or anapplication. It is the framework that establishes the foundations of a software.

5In computing, a back-end (sometimes also called a background) is a term designating an output stage of a software that mustproduce a result. It is opposed to the front-end (also called a frontal) which is the visible part of the iceberg

6API is an acronym for Applications Programming Interface. An API is a programming interface that allows you to ”plug in”to an application to exchange data. An API is open and offered by the owner of the program

7

Collapse Project

4 Levels

The entire game revolves around resolving puzzles and completing levels. In order to solve these levels,

the player will usually have to interact with a set of elements and deduce the different actions that he can

perform. He must finally use this information to make choices and make his way towards the end of the

level. We had to put in place a system that was both flexible and efficient to allow players to create and

share their own levels. We will be looking at the most significant aspects of our system.

4.1 Components

Each level consists of a set of components with which the player must be able to interact. We have

currently implemented a total of ten different components, each serving a particular role.

4.1.1 White Cube

This component is one of the main blocks, used in large quantities in

the levels. It does not have any special functionality. It is used

most of the time as a building block to form the overall look of the

level.

4.1.2 Grey Cube

This component also constitutes one of the main blocks, used in large quantities

in the levels. It does not have any special functionality either. It is used mostly

as a building block to give contrast to certain parts of the level or to delimit ar-

eas.

8

4.1 Components Collapse Project

4.1.3 Starting Cube

The starting point allows the character to appear when the level is initialized. The

position at which it is set defines the beginning of the level. It is generally used only

once per level but it is also possible to place several. Each point of departure will

then reveal a character.

4.1.4 Exit Cube

The end point is the goal of the player for each level. When the character is on the

component, the level is over and the player returns to the menu in which he was pre-

viously. Again, it is possible to place several points of arrival, constituting several

possible objectives for the player.

4.1.5 Gate

The Gate is a dynamic component. It has two states: open and closed.

When closed, the barrier is solid and it is a barrier for the player. On the

other hand, when it is open, the player can pass through without any prob-

lems.

4.1.6 Lever

The lever serves as an activation device. The player can click on it with the

mouse to activate and deactivate it. The activation and deactivation of the lever

are programmable events that can be linked to different actions according to the lev-

els.

4.1.7 Button

The button is also used as an activation device. The player can click

on it with the mouse to activate it. Activating the button is a pro-

grammable event that can be linked to different actions depending on the lev-

els.

9

4.1 Components Collapse Project

4.1.8 Pressure Plate

The pressure plate is also an activation device. The player can activate it by walking

on it and deactivate it by stopping to walk on it. Activation and deactivation are

still programmable events that can be linked to different actions depending on the

levels.

4.1.9 Laser

The laser is a dynamic component. It can be either enabled or disabled.

When activated, it projects an orange laser beam that can be interrupted by

the character and other components. It is often used in conjunction with sen-

sors.

4.1.10 Sensor

The sensor is an activation device. It is activated when a laser beam

comes into contact with the sensor lens. Activation and deactivation are pro-

grammable events that can be linked to different actions depending on the lev-

els.

10

4.2 Level Mechanics Collapse Project

4.2 Level Mechanics

The entire point of the game is about using the different level mechanics in order to complete the different

levels. The player must be able to find a path from the starting point to the ending point represented by

a green teleporter bringing it directly to the level map. The levels must be real challenges for the player

but they also have to offer a great diversity so that the player can progressively face levels of increasing

difficulty without being tired.

Figure 1: Basic level

In order to keep the actual mechanics as generic as possible, we decided to create a completely data-

driven system where each level should be able to provide a list of its components and their names. In

order to store this information in a flexible way, we decided to use JSON 7. This format presented many

advantages, one of them being for instance to easily let us change the format specification over time, as

we were developing the game. Also, learning how to use JSON is really trivial as the syntax uses only a

few marks of punctuation. It also does not depend on any language. Its tree structure and simple syntax

allows it to remain very ”light”.

7This format, from the JavaScript world, allows to store textual data, but not binary data in a structured way. It was created byDouglas Crockford in 2006.

11

4.2 Level Mechanics Collapse Project

{"LevelName": "First level","DeadZone": -5,"Data": {

"#variable": [ "up", "south", "south", "north", "north", "down" ]},"Components": [

{ "Position": [ 1, 0, 1 ], "Prefab": "light_tile", "Ref": "TARGET_2" },{ "Position": [ 1, 0, 0 ], "Prefab": "light_tile" },{ "Position": [ 0, 0, 1 ], "Prefab": "light_tile" },{ "Position": [ 0, 0, 0 ], "Prefab": "start" },{ "Position": [ -1, 0, -1 ], "Prefab": "light_tile" },{ "Position": [ -1, 0, 0 ], "Prefab": "light_tile" },{ "Position": [ 0, 0, -1 ], "Prefab": "light_tile" },{ "Position": [ 1, 0, -1 ], "Prefab": "switch", "Rotation": [ 0, 90, 0 ],

"Events": {"On": [

{ "Action": "Animate", "Target": "TARGET_1", "Animation": [ "down","west", "west" ] },

{ "Action": "Animate", "Target": "TARGET_2", "Animation": "#variable" }],"Off": [

{ "Action": "Animate", "Target": "TARGET_1", "Animation": [ "east","east", "up" ] }

]} },{ "Position": [ -1, 0, 1 ], "Prefab": "light_tile" },{ "Position": [ -4, 1, 1 ], "Prefab": "end", "Ref": "TARGET_1" }

]}

Figure 2: Example of the JSON structure of a level

As you can see, the structure of a file is really basic. A file has two main properties: the level name

and the list of the different level components. The list is represented in JSON by a table. For each com-

ponent, this table contains a name that corresponds to an object model and a location. When launching a

Unity level loads the JSON file and instantiates the prefabs corresponding to the components in the array.

All prefabs that are instantiated in the level come from the same folder in the Resources directory.

This allows us to easily implement new components as we simply have to drop an object into the folder

to make it available as a level component.

Another aspect of level mechanics is the pause mode and start over. We wanted to allow the player

to pause the game and start a new level. To pause the game it is enough to set the time scale to 0. This

means that the time between two planes is multiplied by 0. To restart a level it is enough to reset all the

components of the level, the position of the player and the one of the camera.

12

4.3 The event system Collapse Project

4.3 The event system

As explained earlier, to save the levels, we used JSON files to store all their data. When a level is loaded,

all this information is read and all components are instantiated. These JSON files contain the name of the

level and a list of its components and their information, such as their position, name or rotation. Using

JSON files allows us to store information in a flexible and intuitive way.

We added elements capable of triggering actions. For example, button or lever that when clicked

have an effect on the game. For example, platform made up of white cubes that work as an elevator. We

needed a place to save all of these actions and movements. We finally found a way to store all this in the

JSON files by associating the events with the components. For instance, below, you can find how a lever

is represented in a JSON file.

{ "Position": [ 0, 0, 2 ], "Prefab": "switch","Events": {

"On": [{ "Action": "Animate", "Target": "PLATEFORM", "Animation":

"#PlateformAnimation", "Loop": true },{ "Action": "Open", "Target": "GATE" }

],"Off": [

{ "Action": "StopAnimation", "Target": "PLATEFORM" },{ "Action": "Close", "Target": "GATE" }

]}

}

Figure 3: Detail de la specification d’un evenement

As we can see, the values ”Position” and ”Prefab” are stored, but we can see that there are also

events. The ”Events” data has a list of status. In this case the lever has two states: ”On” and ”Off”. Each

of these states has a list of actions. For the present case we can see that we have 2 action per state. Each

action has a name as well as a list of data necessary for the action to be carried out. If we take as an

example the first action of the state ”On”. The name of this action is ”Animate”. The name will then find

what function of the script should be used. The values that follow the action name will be used as the

parameter of this function. In this case the function needs a target, or an object named ”PLATFORM”.

This name is registered on the platform using the REF data as can be seen above. The function also

needs an animation type, here named ”#PlatformAnimation” as well as a boolean that indicates whether

the animation should start every time it finishes.

13

Collapse Project

5 Level Editor

5.1 Implementation

An essential aspect of our game is to encourage creativity. We decided to give players the opportunity to

create their own levels in order to see what kind of puzzles they are able to create. Therefore, we had to

develop a level editor directly in the game.

As explained earlier, the game entirely revolves around JSON files. The scenes we created in Unity

provide all the logic of a specific section of the game in the most generic way possible. The scene that

allows players to play levels is no exception. The format of the JSON levels is the most complex of

all the representations we have conceived. Making a full-fledged editor capable of generating them was

therefore a significant challenge.

Figure 4: The level editor

14

5.1 Implementation Collapse Project

The level editor allows players to navigate the level by flying around in first person. This makes it

easy to get an overview of the scene. Commands Correspond to the horizontal and vertical standard axis

and the player can change the orientation of the camera by clicking on the center button of the mouse

and moving the mouse. All the other camera controllers that we could find were all too over-equipped

for what we wanted to do. So we decided to create controllers ourselves.

One of the key aspects of the level editor is that it can load the level data into a scene. Fortunately,

we had thought of it when we created the LevelScene scene. To load the levels from the JSON data in the

scene, we created a generic object called LevelEnvironment whose job is essentially to read the JSON

data directly on the files and instantiate all the objects in the scene. This is an important asset since this

behavior is truly generic. JSON data can come from anywhere and the LevelEnvironment script can be

included anywhere.

In the editor, to load the JSON data into the level, we simply copy and paste this script onto the Stage.

Then, the script EditorController, a script that essentially handles what happens globally in the scene,

loads the JSON data from the player’s computer and feeds the LevelEnvironment environment script.

That way, what is built inside the editor is exactly what is generated when you play the level since both

scenes use the same script but in a different context.

Now that the components are loaded into the editor, the next step was to make the player edit them.

We created an object that would act as a cursor and follow all the mouse movements while snapping to

the components of the level. In order to determine the location of the cursor, we used raycasting and

projected rays from the camera according to the mouse cursor position. If the ray hits an object, we

check that it’s a level component by verifying if it has the ”levelComponent” tag. Then, I simply set the

cursor’s position to the position of the component that the ray just hit. You might have noticed in the

screenshot that there is a transparent grid pattern on the floor, it makes it possible to place components

anywhere and not just against other components. The floor has a specific tag as well so I can detect it

and when I do I place the cursor at the same level.

15

5.1 Implementation Collapse Project

Creating and deleting components in the editor was quite easy. Functions were created in the Lev-

elEnvironment class that take care of deleting the object from the scene as well as updating the loaded

JSON data. All our JSON representations are associated with classes that allow us to process the data

they represent by mapping all JSON properties into simple class fields.

The player can select the component he wants to place by se-

lecting it from the sidebar that opens by approaching the mouse

on the right side of the screen. Then the controls are pretty

simple, left click to place the object and right click to delete

it. It is also possible to reorient the selected component by

pressing ”F”. This will position the component in front of

you.

16

5.2 Event Configuration Collapse Project

5.2 Event Configuration

The part that was a bit more complicated was the fact of being able to link actions to the component in-

side the editor. All components can trigger events and command another component to perform actions.

It is an essential part of the game. Having dynamic components that can communicate with each other

opens up a lot of possibilities for level design. It is important that players can use the event system fully

while keeping the interface as simple as possible.

Figure 5: Screenshot of the event menu

One thing that I learned through this process is that making complex user interfaces in unity is really

time-consuming. This menu can be opened by pressing the left alt key and clicking on a component. On

the left, you can see that most of the screen is filled with a large ”list of lists” that allows the player to

add, delete or modify events as well as specific actions to link. On the right is a sidebar that displays the

component type with a small icon and allows you to change the ”Ref” or the component name so that

you can reference them later.

When you open up this menu, the left part of the screen is where the magic takes place. When you

first open it up, you will be able to see it. There is a big button that says ”New event” and lets you

bind a list of actions to a specific event. The large ”event panel” has a dropdown at the top that lets you

choose which event you want to listen to. This dropdown is dynamically updated with the list of events

that the selected component can fire. For instance, ”Start”, ”On”, ”Off” and ”Toggle”. On the other

hand a simple tile will only be able to fire the ”Start” event (The ”Start” event is fired by every compo-

nent when the level finishes loading) and therefore will only let your select ”Start” in the event dropdown

17

5.2 Event Configuration Collapse Project

At the bottom of the event panel, there is another drop-down list that contains all the actions that can

be performed by any level component. Note that even if events are triggered by components that define

actions, actions are ”transmitted” to and executed from target components. Anyway, once you select the

action you want to run, click the “+” button and it will instantiate a field that allows you to change the

target of the action (By default if the field is left blank the component will order itself to perform the

action) as well as additional fields depending on the action selected

There are quite a few actions to choose from, some of them are directly related to specific com-

ponents and others will work on any type of component. For instance, the laser can be ordered to do

actions that are very specific to its type such as to activate or deactivate itself. A more general action that

can be performed on any component would be the ”Animate” action. This action makes it possible to

move components around in the level by specifying a list of directions that the component should move

towards successively. It’s also possible to make the animation loop indefinitely, and to stop it by using

the ”Stop animation” action.

18

Collapse Project

6 Character

6.1 3D Model

The creation of the character was one of the first thing that we decided to do. As we weren’t all familiar

with Blender already, some of us had to spend some time learning the basics of the software. That’s why

this step took us a bit longer than expected. We created several versions of the character until we reached

an enough optimized and aesthetic version. Here is an example of one of the versions followed by an

image of the final version used in the game.

Figure 6: First version

Figure 7: Final version

19

6.2 Character Logic Collapse Project

6.2 Character Logic

Once the final model was finished. We then focused on creating the character’s animations.

It took us a while to figure out how to make it work. It sounds trivial when you simply think about it,

but in practice there is a lot to think about. The first thing is to make sure that in Blender, the animations

are clearly separated on different tracks of action. The character was then imported to Unity. We had

to configure the animations to make them loop in a cycle. The next step was to create an animation

controller that would make transitions and interpolate between animations based on a certain state. This

state had to be driven, so we had to create a controller that would drive the animation according to the

input of the user.

At this point, we thought that there was necessarily a better way to do it. And we were right. Each

game needs a way to control a character in one way or another, so it turned out that a complete character

controller with animations was already part of the standard Unity components . So, instead of reinventing

the wheel, we started again and developed from the basic behavior that the default controller provided.

For example, we changed it so that we could control the character in mid air.

20

Collapse Project

7 Worlds

7.1 World Mechanics

The goal of each level is to help Pip illuminate the path that guides him through the different worlds.

When the player finishes a level, the background lights up and reveals to the player the rest of the way.

The levels are represented by small white cubes. If a level is lit it means that the player has access to it

and can try to solve it.

Here we had to find a way to load the level from the levels map. It was also necessary to have a

system flexible enough to be able to load any level and to point the levels that had already been played.

Like the levels, we decided to store the information of the worlds in files outside Unity. We had to

organize and structure the various files in order to keep a clear and clean plan.

So we decided to put all the levels of a world in a file named after the title of the world. So all the

JSON files in a folder are actually the different levels of the world, they themselves possess the structure

explained previously. In addition to that, every world file has a word.json file containing the information

about the world itself.

{"Name": "World_example","Levels": [

{ "Id": 0, "Name": "level-1", "Position": [ 0, 0 ] },{ "Id": 1, "Name": "level-2", "Position": [ 1, -1 ] },{ "Id": 2, "Name": "level-3", "Position": [ 1, 0 ] }

],"Paths": [

[ 0, 1 ],[ 0, 2 ]

]}

Figure 8: JSON format of a world

The world.json file has three properties: the level name and two tables. The first is an array con-

taining all the names of the different levels. Here each level has information about its location in the

level map. The second table associates two level names which will then be linked together by a line thus

creating a path.

21

7.2 Navigation Collapse Project

Figure 9: How the world tree looks like in-game

It can also be noted that we have created transitions that make the passages of the worlds more aes-

thetic at the levels and vice versa.

We also added transitions to make the shift between scenes more aesthetic.

For this part we were greatly helped by the Unity documentation.

7.2 Navigation

Collapse is composed of many worlds represented by a string of cubes that are connected by a white line.

To allow the player to travel between worlds, before the first level of each world, there must be a way to

go to the previous world. The same goes for the last level, there must be a way to go to the next world.

We first thought of implementing it in the form of buttons or some sort of portal.

We wanted to do something that would keep the spirit of the game while remaining visually interest-

ing. So I made two structures from the cubes that represent the levels in the worlds. One to go back, the

other to go ahead.

22

7.2 Navigation Collapse Project

Figure 10: Navigation

Their position depends on the position of the first and last levels of each world. This allows us to

build worlds as large as we want, without space limitations. They also take into account the world in

which the player is located. For example, in the first world, there is no ”previous world” structure on

the left. At the end of the last world there is a unique and special structure that directs the player to the

credits of the game.

We have also added a script that facilitates navigation within the worlds. First, to be able to navigate

between the different levels of the world we made a script that allows them to scroll. Using the mouse

wheel the player can navigate easily through all the levels of the world. Then to allow the player to locate

himself we made another one that when hovering the mouse over a level its name is displayed above it.

23

Collapse Project

8 Gallery

The gallery is the creative side of the game. After collecting a number of components in the solo game,

players will be able to create increasingly complex levels and share them with the community.

8.1 The local gallery

The custom level gallery will allow the user to play all the levels he has made and continue to work on

them. This is essentially the equivalent of worlds, but for custom levels created by the player. However

there is still a big difference. Normal levels that can be played by selecting them in the base worlds

are loaded as ”Resources”. Resources are loaded in a very specific way by Unity. Once you have built

the game, all the resources are grouped into a single large component that you can access through the

Resources library. The problem is that this huge component can only be read. This raises a problem for

a level gallery where the player is supposed to be able to create and edit levels freely. Fortunately, Unity

provides us with ”Application.persistentDataPath”, a directory that can be used to persevere the data of

the game. Since this is a simple folder, we can do whatever we want inside... problem solved.

Figure 11: The local gallery

24

8.2 The online gallery Collapse Project

The gallery stores all the data it needs in JSON. We decided to adopt an architecture similar to the

one we used for the worlds. We save all the data we need in a subdirectory called ”LevelGallery”. The

most important file here is the one called gallery.json. This is an index of all levels in the gallery and

contains a list of all the names and identifiers of the levels created by the player.

All levels are stored as individual files in the same directory. They are called 0.json, 1.json, 2.json

and so on. The gallery.json file also contains a ”LastID” field that traces the track of the identifier of the

last level created. As you may have noticed in the screenshot, all levels have their own small thumbnails.

These are stored again in a subfolder called ”Thumbnails” following the same naming scheme as the

level files.

The idea behind the user interface was to make it easier for players to identify levels. To do this, we

essentially display a screenshot of the level with its name. The entire left side of the interface can be

scrolled and expanded as the levels are created. At the end of the level list, there is a button that allows

you to create a new level. When you click on it, the game creates a new empty level and loads the level

editor so that you can start building directly.

The sidebar on the right allows you to browse through all the levels you have created. If you start

typing the name of a level in the ”Search level” field, you will see that the level list will dynamically

filter all levels that do not match what you typed. This allows you to find the level you are looking for

more easily. The sidebar also allows you to play, modify and delete the level. When you click Play, the

game loads the LevelScene with the selected level, and when you click Edit, it loads the EditorScene. If

you click Delete, the game updates the gallery index and removes the level file and thumbnail. You can

also rename the currently selected level by simply typing a new name into the level name field.

8.2 The online gallery

The objective of the gallery is also to give the player the opportunity to share his creations with the rest

of the community. we had to think about the implications of such a functionality. We wanted the player

to be able to download and try levels created by others without leaving the game. He also had to be able

to upload his own levels from the game.

Behind the interface, the system relies on a REST API that handles all the logic of the online gallery.

The problem here was indeed to find how to make the navigation and experience of the player in general

more intuitive.

25

8.2 The online gallery Collapse Project

First, to switch between the online gallery and the local gallery, we have set up two buttons ”Local”

and ”Online” that allow you to display the levels created by the player and those created by the commu-

nity, the ones accessible through the API. When the player accesses the gallery from the main menu, the

gallery will be set to “Local” by default.

By clicking on the ”Online” button, the game sends an HTTP request to the API to retrieve the list of

levels of the first page. Each level appears in the same way as the levels in the local gallery, a button with

an image and a title. However, all images must be downloaded individually and waiting for all images to

arrive before displaying anything does not translate into a good user experience. That’s why we decided

to download the images asynchronously. The different levels are displayed as soon as the answer to our

first request has arrived, and the images then appear gradually.

The player must create an account if he wants to benefit from the gallery. Indeed, it must authenticate

itself to bring a level up or put a star at a level created by another player. If the player is not already

logged in, he will be asked to do so when he wants to access the online gallery.

Figure 12: Login and registration pop-ups

When a login window is displayed, the player has several options. First, if the player already has an

account, he simply logs in by entering his username and password. If the player does not have an online

gallery yet, he can create an account. To create an account, click on the ”Register” button in the ”Login”

window to display the registration window. This window is very similar to the login window, however

clicking ”Submit” will create a new account before authenticating the user. The player can also simply

cancel the action he was about to do by pressing Esc.

26

8.2 The online gallery Collapse Project

Figure 13: Online gallery

As you can see, once loaded the sidebar of the online gallery looks very much like the one of the

local gallery. Indeed, there is always the possibility of looking for particular levels and it can be noticed

that the Local button is now available. Clicking on will reload the local gallery.

The section below shows some information about the selected level. You can see the name of the

level as well as that of its creator. By clicking on the Play button, the game downloads the level before

launching it like any other level.

The last part of the sidebar concerns the stars that the level has received. Here we see that three

different people put a star on this level. The “Add Star” button allows the player to put a star on the

selected level if he likes it. He can’t put more than one.

Also, there is a button to go to the next page. In the same way, the game will display a button leading

to the previous page automatically.

27

Collapse Project

9 The Collapse API

As seen in the previous section, the game relies on a REST API to allow players to share their levels

between them. We will therefore look in depth at its different characteristics and its functioning.

9.1 General Information

Our REST API is developed in Python using the Django framework and complemented by the excellent

”Django rest framework”. The API relies entirely on the JSON format to serialize the response of the

different queries. The root of our API is located at the following address:

https://collapse3d.com/api/

If we make a request at the root, we get two links to the two lists of objects with which we will be

able to interact.

HTTP/1.1 200 OKContent-Length: 91Content-Type: application/json

{"levels": "https://collapse3d.com/api/levels/","users": "https://collapse3d.com/api/users/"

}

We can therefore access two different collections, the levels published by the players and the users,

the accounts of the players themselves.

28

9.2 Users Collapse Project

9.2 Users

Users are created from the game when the player has to log in but does not have an account yet. Once

created, the user account allows to retrieve all levels created by the user himself as well as all the levels

to which he has put a star. This is the format of the JSON returned by the API during a GET request on

the index:

{"count": 5,"next": null,"previous": null,"results": [

{// user object

},{

// user object},...

]}

As we can see, the list of users is paged. The ”next” and ”previous” keys contain respectively the

URLs leading to the next page and to the previous page if they exist. In case a next page exists, the value

of ”next” will be equal to ”https://collapse3d.com/api/levels/?page=2” if the previously requested page

was the first page. The ”count” field represents the total number of items in the collection.

We can now look at the structure of the object representing a user. Here is an example highlighting

the different information available by retrieving a particular user from the API:

{"url": "https://collapse3d.com/api/users/2/","id": 2,"username": "some_guy","custom_levels": [

"https://collapse3d.com/api/levels/40/","https://collapse3d.com/api/levels/43/"

],"stars": [

"https://collapse3d.com/api/levels/22/","https://collapse3d.com/api/levels/24/","https://collapse3d.com/api/levels/37/"

]}

So we have first the key ”URL” which contains the address to which we can retrieve this particular

user object alone, outside the list. The ”id” key contains the identifier used by the server to index our

particular user object. This identifier is unique. The ”username” key contains the user’s name of the

account that it represents. This name is unique and public.

29

9.3 Registration Collapse Project

The last two keys provide different information about particular levels. The ”custom levels” key

contains an array containing all links to user-posted levels. Finally, the ”star” key contains an array con-

taining all the links to the levels to which the user added a star.

9.3 Registration

To create a new account, you must go through the users list. Send a POST request to ”https://collapse3d.com/api/users/”

to create a new user. However, to specify the username and password for the new account, you must at-

tach a form containing the ”username” and ”password” fields to the body of the request. If successful,

our server returns a status of type 201 8, Specifying that the user was created.

Regarding security and password protection, we have configured our server so that it can only serve

the API under HTTPS with HSTS enabled. This makes the risk of Man-in-the-middle attacks 9 extremely

low.

On our server, we only store a database version of the password that has been chopped and can not

be decoded. This means that in the event of an attack on our server, a hacker will not have access to the

passwords of our users.

9.4 Login

Once registered, the user needs to be able to log in and start a session. Authentication is managed using

tokens 10 that expire after a fixed period of time. To generate a new token, simply send a POST request

to the address ”https://collapse3d.com/api/login/”. The server therefore needs our login credentials. A

form is then attached to the body of the request containing a ”username” field and a ”password” field.

If successful, the response contains a JSON object with a single key: a new token corresponding to

the user’s session.

This token must be kept at the client level because it will be used to authenticate itself everytime it

needs to connect to a url that requires the user to be connected. To access a url in an authenticated way,

8The HTTP status code 201 Created indicates that the request was successful and that a resource was created accordingly. Thenew resource is actually created before the reply is returned and is returned to the message body.

9The man-in-the-middle attack is an attack that intercepts communications between two parties, The other can not suspect thatthe channel of communication between them has been compromised. The most common channel is a lambda internet connection.The attacker must be able to observe and intercept messages from one victim to another.

10electronic boxes generating numbers for authentication or storing encrypted information

30

9.5 Levels Recovery Collapse Project

{"token": "6429ff0090bbe617b855b859158ed0708695e8fe"

}

the client must include the ”Authorization” header in its request. It must specify the token as follows:

POST https://collapse3d.com/api/levels/ HTTP/1.0Host: collapse3d.comAuthorization: Token 6429ff0090bbe617b855b859158ed0708695e8fe

If the token is valid, the inclusion of the header allows to perform actions available only to the con-

nected users like posting a level for example.

9.5 Levels Recovery

The reason we needed to create this API is to be able to manipulate a table of levels in a secure way. The

interface proposed by the API to interact with them is therefore an essential aspect of our API.

The address ”https://collapse3d.com/api/levels/” is the index of the levels published by the players.

To get a list, you just need to make a GET request to this address. A result in the form of JSON is

obtained which is as follows:

{"count": 19,"next": "https://collapse3d.com/api/levels/?page=2","previous": null,"results": [

{// level object

},{

// level object},...

]}

Like the user list, the list of levels is paged. The overall structure and operation is identical, only the

objects contained in the ”results” table differ.

We can look at the structure of objects representing the different levels. Let’s use an example:

31

9.6 Interaction with the Levels Collapse Project

{"url": "https://collapse3d.com/api/levels/39/","id": 39,"name": "Something","stars": 0,"file": "https://collapse3d.com/media/levels/Something.json","thumbnail": "https://collapse3d.com/media/levels/thumbnails/Something.png","created": "2017-05-25T15:35:19.729562Z","author": "https://collapse3d.com/api/users/11/","author_name": "foo"

}

The key ”url” contains a link that allows to display this level alone, outside the list. The ”id” key

contains the identifier used by the API to index the database level. The ”name” key contains the name of

the level and ”stars” the number of stars received by this level.

Then there are two keys that refer to files that are necessary for the game to work. The link contained

under the ”file” key returns to the JSON file which describes the level, with the different components and

events. The key ”thumbnail” as for it, returns to the screenshot that must be used to display the level in

the gallery.

The ”created” key specifies the date and the creation time of the level. The link in the ”author” key

refers to the object representing the creator of the level. Finally, the key ”author name” contains the

name of the creator.

9.6 Interaction with the Levels

Whether it is to post one of its own levels or to put a star on a level created by another player, the player

must be authenticated. All requests in this section must be sent with the ”Authorization” header as spec-

ified in the section on authentication.

To post a level, you must send a POST request to the index of the list of levels ie ”https://collapse3d.com/api/levels/”.

Of course, the client must provide the server with the resources associated with the level. It is therefore

necessary to attach a form to the body of the request to transmit all this information. The form must first

specify a ”name” field which must contain the name of the level. Then include the JSON file representing

the level in the ”file” field as well as the screenshot of the level in the ”thumbnail” field.

If the sending was successful, the server will respond with a status 201, meaning that the level has

been posted.

32

9.6 Interaction with the Levels Collapse Project

Now that players could post their own levels and share them with the community, we needed to make

sure they could give a star to their favorite levels.

We saw that it was possible to access a level by using an address of this form: ”https://collapse3d.com/api/levels/[id]/”

where ”id” is the identifier of the level in question. We made possible to call a ”function” that adds a star

to a particular level. Sending a POST request to the address ”https://collapse3d.com/api/levels/[id]/add-

star/” allows to call this function and add a star to the level whose identifier matches ”id”.

A player can only grant one star per level and he can not put a star at his own levels. We verify that

the authenticated user is not the same user who created the level.

33

Collapse Project

10 Main Menu

The first time the player plays the game a small animation of Pip walking is presented to him. This

animation allows in reality to make the player wait while the game creates savings so that the player can

keep his progress.

The main menu allows the user to reach all the parts of the game. It’s the starting point. It is composed

of 5 buttons. The first one leads to the last world in which the player played. The second gives access

to the gallery and to the editor of levels. The third allows the player to connect with a friend to solve

levels in cooperative mode. With the fourth one, ”Settings”, the player can change his identifier as well

as the controls of movement. Finally, we have the button ” Exit ” so that the user can quit the application.

Figure 14: Menu

The objective was to create a simple, esthetical menu and which was in the sale atmosphere as the

one of the game while remaining sober and functional. To achieve all of this some choices had to be

done :

34

Collapse Project

At first, we chose an identical colour palette as the one that we can find in the levels. It is mainly

constituted of white (basic cubes item), grey (cubes, background) and orange (main character as well as

certain details of objects).

Figure 15: The color pallet

The aesthetics of the game is mainly about the white cubes of which the levels are composed and

with which the player can interact. Consequently, to keep this concept we decided to place the menu

inside a cube. When the player opens for the first time Collapse, there is almost no light on the scene.

The darkness prevails. As the player will move forward in the levels the menu scene clears up until it

becomes almost completely white. Naturally we watched that the different buttons still visible.

The game style is characterized by its geometrical forms, its sharp edges and its brightness. To keep

this style, we opted for a basic and clear police for the text inside button. For the title we used a more

geometrical and stylized police which attributes itself a certain personality. Button are simple. Translu-

cent grey rectangles with slightly rounded off edges and a white text. When the player passes the mouse

over them colours are inverted, the text becomes grey and rectangle becomes white.

Finally, to add of the originality to the menu, the character is also in the cube and the user can play

with him. Nevertheless, to keep him in background, I used a fuzzy effect on the camera.

35

Collapse Project

11 Cooperative Mode

The cooperative mode allows two players to join in order to solve a set of levels which are impossible to

solve individually. These levels are situated in a ”parallel” universe to the solo levels one. However, a

difference is that there are a lot less cooperation levels than regular levels.

To be able to adapt the scripts that were already existing to the multiplayer mode, we had to under-

take many modifications into our code to integrate a logic of separation between the customer’s part and

the server’s part.

As a result, the multiplayer mode unfortunately doesn’t have all of the features that are available in

the regular singleplayer mode.

It turned out that our event system is pretty hard to translate into logic that can work across the

network. Indeed, we tried a lot of potential designs, but all of them ended up being too limited regarding

the capabilities of the different components. One of the common issues was handling the client authority

assignments in order for components to be able to send commands to the server. However, commands

can not accept just any type of argument and some of our trials made use of a lot of serializing and

parsing in order to retrieve the object that was firing the event.

In the end, we rolled back our various experimentations in order to be able to provide a clean build

of the game. Levels that can be played in the cooperation mode are therefore currently limited to static

levels, that is to say levels that don’t feature any dynamic component or animation.

Once this stage was done, we were able to connect together two authorities of the game in the same

level. There was however an important question to solve. How can an authority of the game connect

spontaneously to another one?

We decided to use the Unity matchmaking services and decided to build on top of it in order to

abstract all the room mechanics away from the foreign user. The final goal was to be able to either team

up with somebody randomly, or with a particular player by mentioning his user name. This way, the only

thing that the end user has to worry about is whether he wants be with someone in particular or not.

36

Collapse Project

12 Website

The web site allows the player to be informed about the news of the game, to connect in its personal

space, to be able to see all the levels that it created and to share them with the other players. He can also

discover the levels created by other players and note them.

12.1 Front-end

To be able to create the web site, we had to learn the HTML languages (which allows us to create the

contents of the site), CSS (which allows us to shape the site) but also the Javascript language allowing

us make a more dynamic site by adding for example fields of control of the password and the e-mail

address of the player.

What is always a little complicated when creating a web site, is that even if you have all the necessary

knowledges you never really know where to begin. We thus realized a paper model to visualize that we

wanted to obtain and that’s what allowed us to be more effective afterward.

The site consists of five HTML files: the homepage (which holds the player informed about the

various news), the page of the resources (on whom you can learn more about the design of the project,

download report and download the game), the gallery (in whom the player can find the levels of the other

players and note them) and finally pages of connection and registration.

The connection and registration pages allow the player to reach a personal space.

Thanks to the Javascript language the forms are able to verify the validity of the e-mail address of the

user and indicate him the security level of its password. In order to obtain password whose safety is

maximal, the latter has to contain at least a capital letter, a figure and has to have a length superior to

6. The information is then sent and red in order to verify the existence of the account in the case of the

connection page or to create one in the case of the registration page. The player can also receive his

password by e-mail if he forgot it.

Once connected the player has access to a personal gallery containing his own levels and all the in-

formation about them (grade of the level, the number of times it has been played, . . . ).

For each of the galleries we can sort out the levels according to various characteristics: from the more to

less recent, from the least popular and to most on and in alphabetical order.

37

12.2 Back-end Collapse Project

12.2 Back-end

The architecture of our back-end plays a crucial role in the implementation of the different features of

the game and of the website. Indeed, the community part of the game is entirely based on the API.

Our back-end consists of a Django application that runs under python 3.6. Django is a web frame-

work written in python and used by a lot of industry leaders such as Pinterest. The clarity of the Django

library allows us to develop a solid infrastructure that focuses on our application’s logic.

The database we decided to use is SQLite. The SQLite databases has the property of being stored in

a single file. This represents a big advantage for the development because we can easily copy-paste the

file to replace it with a new version. The advantage of using Django is also that we can automatically

export the fields of our database and reload them with another compatible database. It means that we

can make a change for a better database that will more adapted to the productions environments such as

PostgreSQL at any time.

In terms of server configuration, we decided to go with one of the most popular architecture amongst

Django users. We use Nginx to serve the static files and we redirect the other requests towards a Guni-

corn daemon on whom our application is running.

The site benefits of a secured connection thanks to a SSL certificate delivered by Let’s encrypt whom

we automatically renew using a cron task. Nginx was configured to redirect all the connections under

HTTPS. We also activated HTTP2 to allow a faster load as well as HSTS to limit at the maximum the

possibility of man-in-the-middle attacks.

38

Collapse Project

13 Personal Conclusion

13.1 Gael de FRANCONY

The group of Collapse has been recomposed several time. Originally, only Valentin and Emma worked

on this project. Edward and I worked on another game named ”Decrypted”. The fusion took place after

the first presentation. We decided to continue with the project ” Collapse ” because it interested all the

members of the group. The biggest challenge for me was thus the adaptation to this new project. It is the

challenge of understanding how the game works: the scripts, its mechanics, etc. As well as understand-

ing its spirit and objectives.

Concerning knowledges acquired by working on this project, for my first game ”Decrypts” I took

care of the Website. Thus I have make big progress in Css, HTML and JS as well as in server’ adminis-

tration. I also made most of the aspects bound to Unity. Thus I learned to master this software.

For Collapse I focused on certain aspects of the games bound to its mechanics. I had to work with

the some of the scripts. I had to learn how to use JSON files and to implement them in the game. I also

had to work a lot with overleaf since for the last presentation a was in charge of the report as well as the

operating document. Therefore, now, I feel quite comfortable with Latex. Finally, I had to many of the

levels. I have to admit I underestimated this part of project. To be able to create a complex puzzle that is

difficult to solve is harder than what we thought.

The production of this game taught me many things in general. I understood how much communica-

tion is important for a group based project as well as organization. It also allowed us to use our skills for

a concrete objective.

39

13.2 Edward CACIOPPO Collapse Project

13.2 Edward CACIOPPO

During my first defense I was working with Gael on a project called ”Decrypted”. During the creation

of our game, I had to learn to use various software under free license for the manipulation of 3D models

(Blender and Makehumans).

Despite the great work we did, it was not possible for us to continue being only 2, we were then put

in team with Valentin and Emma. After a meeting with this new team we agreed to continue Valentin

and Emma’s project.

Consequently it is a game with all these mechanics of inclusive bases, I had to at first get acquainted

with all the work already made to be able to work. So I learnt a new format, Json as well as its use in the

scripts with the language C #.

I have afterward been interested in various bookshops offered by Unity to give better sensations of

game. That is the creation of GUI or the use of the various peripheral rings of the computer, Unity taught

me the use of these various commands.

40

13.3 Valentin BERLIER Collapse Project

13.3 Valentin BERLIER

This project gave me an opportunity to experiment with a domain that always interested me, game de-

velopment. I was excited about it plus I was already familiar with the world of computer graphics as I’ve

used Blender a lot in the past for personal projects. In the same way, I’ve been really enjoying C# over

the last year and I was looking forward to work with the language a little bit more. What I’m trying to say

here is that I really liked working on this project as it provided an interesting but also a fun experience.

Unity features a large set of high-level tools that usually makes it easy to abstract away implementation

details, allowing you to really focus on the game logic.

Regarding the game’s development, I took care of the creation of the level editor as well as all the

parts of the project that needed to communicate with our server. The level editor was really interesting

to implement. I had to deal with a lot of different things at the same time and I think that it was for

me one of the most rewarding experience of the project. Another interesting learning experience was

the network handling for the cooperation mode, especially the logic that I implemented on top of the

matchmaking service.

Another interesting aspect of the project was the integration of our custom API. I’ve been looking

on and off into web development for a few years now and I think that I managed to use my experience

by setting up our back-end infrastructure, that is to say creating the API itself as well as configuring our

server.

Finally, I would say that this project allowed us to test and use our skills but more importantly

it allowed us to end up with a concrete result. That represented for me an interest of a whole new

dimension.

41

13.4 Emma PAYAN Collapse Project

13.4 Emma PAYAN

At the beginning of the year I frankly knew nothing to programming. This project not only allowed me

to put into practice some bases acquired during the first half of the year but I also discovered numerous

software such as Blender and learned new languages (HTML, CSS, Javascript) in particular thanks to

the conception of the website.

As I am attracted by the domain of the art and the design, I really liked discovering the Blender

software and realizing small animations such as levers or buttons. For the conception of the character

I was helped a lot by the on-line courts classes of the Openclassroom.fr website which explains lot of

different ways to realize Blender models.

I also enjoyed realizing the website, it is something which I had always wanted to make and I plan to

continue to learn new things in this domain to be able to improve myself.

Also, beyond the technical aspect I learned some rudiments related to the conception of a project such

as time management on a long lasting or the teamwork organization. Being a summer camp counselor,

I learned, during various stays of holidays, to work in team on short duration (1 or 2 weeks). But the

experience is very different in both cases. I also realized a expression courses during the Easter holidays

which helped me for the various presentations.

Finally, this project allowed me to imagine the work conditions of someone working in a company

and what a professional project could look like.

42

Collapse Project

14 Conclusion

All in all, we can say that we successfully managed to create a video game in C# over a period of 5

months. We reached most of the goals we had fixed in the book of specification regardless of the diffi-

culties we met.

This project took us as much of technique and personal involvement as of cooperation and team work.

It allowed us to expand our programming knowledges, to put in practice the knowledges we already had

thanks to the classes but we also discovered, during these five months, how to manage the time we had

and how to work in team. Those new skills seem now essential to us for anyone that plans to work in the

corporate world.

This game also reflects the motivation and involvement of each member of the group in what is a

first experience of a long term team project for us. Each one brought his knowledges to the project and

learned from the ones of the other members of the group.

43