Update README.md

Added controller warning

DESIGN.md

@@ -1,3 +1,7 @@
 # Launcher
 
 Refer to [docs/launcher/README.md](docs/launcher/README.md)
+
+# Engine
+
+Refer to [docs/engine/README.md](docs/engine/README.md)

INSTALL.md

@@ -1,7 +1,22 @@
 # How to install Boulevard Combattant?
 
+## Windows
+
 To run Boulevard Combattant, simply get the [latest release](https://gitlab.istic.univ-rennes1.fr/fautin/jeu-de-combat/-/releases) and run the executable JAR. You need Java >8 installed on your computer. All libraries are packaged within the JAR.
 
+## Linux
+
+You will need to build the project, as creating a working .jar has proven more difficult than expected. You need `openjdk8`, not `openjdk8-headless`, installed on your computer.
+
+## MacOS
+
+We do not provide support for MacOS. It may work though... Try to build it!
+
 # How to build Boulevard Combattant?
 
-This project is managed via Maven. To build, simply clone the project, and run `mvn package` in the root directory of the cloned project. A JAR will be generated in `${project_folder}/target`. This project can also be imported in your prefered IDE. To run the game, run the Main class located in the default package.
+In order to ensure proper building of the project, clone this repository using your favourite IDE and run the `Main` class.
+This project is managed via Maven. All dependencies are automatically downloaded as required.
+
+## Packaging
+
+To package, simply clone the project, and run `mvn package` in the root directory of the cloned project. A JAR will be generated in `${project_folder}/target`.

README.md

@@ -1,38 +1,37 @@
 ![Boulevard Combattant Logo](src/main/resources/launcher/logo.png)
 
-# Boulevard Combattant
+# 👊 Boulevard Combattant
 
-2D Fighting game, inspired by Street Fighter III: Third Strike.
-Developed in the context of an end-of-year project at ISTIC (2020/2021)
+[**Watch the game trailer now**](https://www.youtube.com/watch?v=Bg_Tftfuyt0)
 
-<figure class="video_container">
-  <iframe src="https://www.youtube.com/embed/E0YPzBLoElg" frameborder="0" allowfullscreen="true"> </iframe>
-</figure>
+Boulevard Comabattant is a 2D Fighting game, inspired by Street Fighter III: Third Strike. Challenge your friends in an epic faceoff on the streets of Angoulême!
+
+Built upon our lwjgl and glfw based game engine, BK Engine, Boulevard Comabattant was designed to be easily expansible in the future.
 
 ![Game screenshot](docs/game_screenshot.png)
 
-Currently, only a single character is playable. However, the engine allows for easy expansion in the future.
+## 🎮 How to play?
 
-## How to play?
-
-Set your preferences in the launcher window, plug-in two DirectInput or XInput capable controllers in your computer, and press start! Use the left analog stick or the D-Pad to move, and the four face buttons for kick and punch, neo-geo style.
+Set your preferences in the launcher window, plug-in two DirectInput or XInput capable controllers in your computer, and click **Play**! Use the left analog stick or the D-Pad to move, and the four face buttons to kick and punch, neo-geo style!
 
 ![Launcher screenshot](docs/launcher/launcher_screenshot.png)
 
 Blue, the main character, knows some advanced martial arts techniques, which can be unlocked through special combinaisons ;).
 
-## How to install / build?
+⚠️ The game does not support keyboard input, only gamepad input. **Controllers are required.**
+
+## ⚙ How to install / build?
 
 Please refer to [INSTALL.md](INSTALL.md).
 
-## Technologies used by the project
+## 🧪 Technologies used by the project
 
-* Java
-* OpenGL via [lwjgl](https://www.lwjgl.org/)
-* OpenAL via [lwjgl](https://www.lwjgl.org/)
-* [JavaFX](https://openjfx.io)
+* Java 🍵
+* OpenGL via [lwjgl](https://www.lwjgl.org/) 📺
+* OpenAL via [lwjgl](https://www.lwjgl.org/) 📢
+* [JavaFX](https://openjfx.io) 🪟
 
-## Authors
+## ⌨ Authors
 
 * [François AUTIN](https://gitlab.istic.univ-rennes1.fr/fautin)
 * [Victor AZRA](https://gitlab.istic.univ-rennes1.fr/vazra)
@@ -40,3 +39,6 @@ Please refer to [INSTALL.md](INSTALL.md).
 * [Antoine DUPUIS](https://gitlab.istic.univ-rennes1.fr/18002392)
 * [Léo NOLIÈRE](https://gitlab.istic.univ-rennes1.fr/lnoliere)
 * [Rémi RATIVEL](https://gitlab.istic.univ-rennes1.fr/rrativel)
+
+
+*Developed in the context of an end-of-year project at ISTIC (2020/2021).*

docs/engine/README.md

@@ -0,0 +1,86 @@
+# Boulevard Combattant 2D Engine
+
+## What does the engine do?
+
+The goal of the engine is to determine a representation of the element described in the gameplay package.
+## Functionality
+
+The engine can create a window apply an aspect ratio, and dynamically as the window resize maintain the graphic environment as the selected aspect ratio.
+
+Display 2d model on the screen apply texture/shader to them, every basic geometric transformation: translation, rotation, scaling.
+
+Built-in HUD system, the engine is able to create an object and make it keep track of the position/scaling of the camera.
+For this release three types of ui element exist: basic geometric shape, text and progress bar but this is a really easy system to expand on.
+
+Sound is also managed by the engine, with the help of the OpenAl library we can recreate 3d sound, doppler effect and such in the game albeit these effects are unused by the game at the moment.
+## Behaviour
+
+At every call of the `engine.render()` method every Object added to the render queue is rendered in accordance with the shader chosen.
+
+<div id="HDIK">
+    <h2>
+        How does it work?
+    </h2>
+</div>
+
+Because our engine uses the OpenGL API every object in the scene is represented by a vertex array object, this array keep track of every vertex, indices, color and textureUV information. All of these informations are encapsulated in the `VertexArray` class. 
+
+A vertex array work in tandem with a shader to show the object as our artist intended, shader are written in the glsl standard of the OpenGl library. Those small programs are sent to the gpu and are used in two phases, the vertex calculation and the fragment one, the first is used to calculate the position of the vertex in the game world and through the projection, the second one is used to calculate which color each pixel on the screen should be. These two part essential for the creation of an object are encapsulated in the `ObjectGl` class which is the most used class in the engine.
+Through this class you can apply transformation to the object, modify shader, vertex array etc...
+
+Now these objects are used by the engine class who store every one of them in a `arrayList`, at every call of the `render()` method these `ObjectGl` are draw on the screen according to the rule specified in their shader and vertex array.
+
+Inputs are collected via the use of the `update()` method for every interaction a callback has been created in the `Input` package through these callbacks we can fetch for example which key has been pressed on a keyboard.
+## Brief package presentation
+
+### camera
+
+A camera is represented by a 3D vector in the world space the main class in the package camera can be used to modify the position, zoom in or out.
+Tracking class are used to control automatically the behavior of the camera. 
+
+`TrackingSF3ThirdStrick` is an imitation of the camera behavior in the game Street Fighter 3 Tracking is updated every frame in the `engine.update()` method
+
+### graphics
+
+Here are the class who make the connection between our program and the OpenGl API as we talked in the <a href="#HDIK"> How does it work ?</a> section.
+
+### gui
+
+Every class here inherited from the `UIDummy` class, they represent special type of `ObjectGl` who translate/scale with the camera.
+
+### input 
+
+`Button` was created to allow rebinding of the key, a feature that has not been added in the game yet.
+`GamepadInput` and `KeyboardInput` are the classes used to fetch which key has been used every frame
+
+### loader
+
+In some optimization effort some texture are loaded all at once and reused without ever needing to reload the texture from the file.
+
+### math
+
+Every class used to represent the geometrical shape `Primitive`, and the operation associated with it `Matrix4f` and `Vector3f`.
+### object
+
+The `ObjectGl` class and his derivatives as we explained in the <a href="#HDIK"> How does it work ?</a>
+section.
+
+### object_wrapper
+
+Some type of structure need to use multiple `ObjectGl` at once like `Text`
+
+### sound
+
+Basic OpenAl implementation completely functional, not used.
+
+### utils
+
+Every tool needed for accessing files and create buffers.
+
+### Engine
+
+The main class in which you can control the whole behavior of the graphical application. The game should be created around the class.
+
+## Main contributors of the engine
+### Antoine Dupuis
+### Léo Nolière

docs/launcher/README.md

@@ -1,5 +1,7 @@
 # Boulevard Combattant Launcher
 
+By [François AUTIN](@fautin) & [Indy BOYEAU](@iboyeau).
+
 ## What is the launcher about?
 
 In order to allow for the end-user to properly input its preferred parameters, we needed a user interface to edit the game.set JSON configuration file (which is then parsed by the game engine to configure itself). Therefore, a launcher window providing basic configuration toggles and boxes was implemented.
@@ -30,20 +32,34 @@ Any JavaFX `Application` class instance must have a `start(Stage primaryStage)`
 
 `launcher.Launcher` also contains additional methods to be launched through user input:
 
-* runGame(): transcribes the user inputed data to a format usable by `launcher.Settings`, asks the `launcher.Settings` instance linked to the launcher to write the game.set JSON file, hides the window and creates a new thread containing an instance of the `gameplay.match.match` class. Upon thread completion, the window is shown again.
+* `runGame()`: transcribes the user inputed data to a format usable by `launcher.Settings`, asks the `launcher.Settings` instance linked to the launcher to write the game.set JSON file, hides the window and creates a new thread containing an instance of the `gameplay.match.match` class. Upon thread completion, the window is shown again.
 
-* fillArraySettings(): transcribes the user inputed data to a format usable by `launcher.Settings`.
+* `fillArraySettings()`: transcribes the user inputed data to a format usable by `launcher.Settings`.
 
-* hideWindow(): hides the launcher window.
+* `hideWindow()`: hides the launcher window.
 
-* showWindow(): shows the launcher window again.
+* `showWindow()`: shows the launcher window again.
 
-* quit(): calls `System.exit(0);`.
+* `quit()`: calls `System.exit(0);`.
 
-* website(): opens the gitlab page of the project in the user's default web browser on click.
+* `website()`: opens the gitlab page of the project in the user's default web browser on click.
 
-* chp(): part of the obscured character select pane. Changes the character image according to the user selected character.
+* `chp()`: part of the obscured character select pane. Changes the character image according to the user selected character.
 
 ### launcher.Settings
 
 This class is specifically made to bridge between the launcher itself, and the resulting game.set JSON configuration file. `launcher.Settings` parses game.set using `com.googlecode.json-simple`, a JSON parser for Java, upon instanciation. It also provides a `write(...)` method to write the user inputed settings to file.
+
+# Task repartition
+
+`launcher.Launcher` and all its dependent resources (`launcher.fxml` & `style.css`) were written by @fautin.
+
+`launcher.Settings` was co-written by @fautin and @iboyeau.
+
+`match.match` methods relevant to parsing the game.set file were co-written by @iboyeau and @fautin.
+
+Launcher logo was designed by @rrativel.
+
+# TODO
+
+As-is, the launcher works well. Future updates may include improvements to the launcher's layout and looks and reintegration of the character select pane.