diff --git a/.gitignore b/.gitignore
index 1c2d52b6c9c31d02d96bdbd5f5c273d8f68efcb9..c3da2901346320a27a84f176e9bd3248a3e21438 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,2 @@
.idea/*
+
diff --git a/app/controller/ClassementController.php b/app/controller/ClassementController.php
new file mode 100644
index 0000000000000000000000000000000000000000..87478040acc6e1a95f35fb2d2d7675359f42ddda
--- /dev/null
+++ b/app/controller/ClassementController.php
@@ -0,0 +1,22 @@
+<?php
+
+class ClassementController extends Controller { // classe de contrôleur pour l'affichage des classements
+ public function display() {
+ $slug = $this->route["params"]["slug"]; // on récupère le "slug", en gros tout le reste de l'URL qui n'a pas encore servi
+
+ //explode du slug pour savoir si on veut le classement par jeu ou global
+ $parts = explode("/", $slug); // on sépare la requête selon les /, et on regarde ce qu'on connait comme ordres dedans
+ if($parts[0] == "jeu") { // && count($parts) == 2) { // on veut consulter le classement d'un jeu
+ $this->view->lejeu = $parts[1];
+ $this->view->classement = Classement::getFromSlug($parts[1]); // on utilise le modèle pour aller chercher en BDD le classement relatif au jeu qui nous intéresse
+ }
+ else { // if($parts[0] == "global") { // on veut consulter le classement d'un jeu (on en fait le cas général pour éviter les pages blanches)
+ $this->view->lejeu = "général";
+ $this->view->classement = Classement::getGlobal(); // on utilise le modèle pour aller chercher en BDD le classement relatif au jeu qui nous intéresse
+ }
+
+ // et classement/global pour le classement général
+
+ $this->view->display(); // on affiche ce classement
+ }
+}
diff --git a/app/controller/IndexController.php b/app/controller/IndexController.php
new file mode 100644
index 0000000000000000000000000000000000000000..d921451640e49e2f6a4d8a62507956c9a5ec3859
--- /dev/null
+++ b/app/controller/IndexController.php
@@ -0,0 +1,11 @@
+<?php
+
+class IndexController extends Controller { // contrôleur pour la page d'index, qui hérite de la classe mère abstraite Controller
+
+ public function display() {
+ // là on peut faire un tas de trucs cool, genre déclarer et initialiser les variables d'affichage par exemple !
+ $this->view->list = Jeu::getList();
+ $this->view->listprofils = Profil::getList();
+ $this->view->display(); // et on appelle la méthode display() qui va afficher la page
+ }
+}
diff --git a/app/controller/JeuController.php b/app/controller/JeuController.php
new file mode 100644
index 0000000000000000000000000000000000000000..52d8547a6d3b731a857116c10f6823a51008488e
--- /dev/null
+++ b/app/controller/JeuController.php
@@ -0,0 +1,14 @@
+<?php
+
+class JeuController extends Controller {
+ public function display() {
+ $slug = $this->route["params"]["slug"];
+ $this->view->jeu = Jeu::getFromSlug($slug);
+ $this->view->display();
+ }
+
+ public function displayListe() {
+ $this->view->liste = Jeu::getList();
+ $this->view->display();
+ }
+}
diff --git a/app/controller/ProfilController.php b/app/controller/ProfilController.php
new file mode 100644
index 0000000000000000000000000000000000000000..96d395396630046a65dbe5d30f8b021165cf5dd8
--- /dev/null
+++ b/app/controller/ProfilController.php
@@ -0,0 +1,9 @@
+<?php
+
+class ProfilController extends Controller { // classe de contrôleur pour l'affichage des profils
+ public function display() {
+ $slug = $this->route["params"]["slug"]; // on récupère le "slug", en gros tout le reste de l'URL qui n'a pas encore servi
+ $this->view->profil = Profil::getFromSlug($slug); // on utilise le modèle pour aller chercher en BDD le profil qui nous intéresse
+ $this->view->display(); // on affiche ce profil
+ }
+}
diff --git a/app/kernel/Controller.php b/app/kernel/Controller.php
new file mode 100644
index 0000000000000000000000000000000000000000..f167d641a9f4cac2cc7e76be0dadbd9d0d210f1e
--- /dev/null
+++ b/app/kernel/Controller.php
@@ -0,0 +1,11 @@
+<?php
+
+class Controller { // classe abstraite de contrôleur
+ protected $route; // variable protégée contenant le résultat de l'analyse de la requête (dans un tableau)
+ protected $view; // variable protégée contenant la vue correspondant à la route donnée
+
+ public function __construct($route) { // constructeur
+ $this->route = $route; // on stocke la route donnée en paramètre dans la variable protégée du même nom
+ $this->view = new View($route); // on instancie une vue avec cette route, et on la stocke dans la variable protégée $view
+ }
+}
diff --git a/app/kernel/Database.php b/app/kernel/Database.php
new file mode 100644
index 0000000000000000000000000000000000000000..8cde5e191acde25b92a50820ca0190f08d198024
--- /dev/null
+++ b/app/kernel/Database.php
@@ -0,0 +1,27 @@
+<?php
+
+class Database { // classe de gestion de connexion à la BDD
+ static protected $_instance = null; // variable contenant l'instance de connexion à la BDD, null par défaut
+ protected $_db; // variable contenant la connexion PDO Ã la BDD
+
+ static public function getInstance() { // renvoie un instance de connexion à la BDD
+ if(is_null(self::$_instance)) { // si on n'a pas encore réalisé de connexion
+ self::$_instance = new Database(); // on réalise la connexion en instanciant la classe Database
+ }
+ return self::$_instance; // on renvoie l'instance qui contient tout ce qu'il faut
+ }
+
+ protected function __construct() { // constructeur, qui instancie PDO pour se connecter à la BDD et qui stocke cette connexion dans l'attribut $_db
+ $this->_db = new PDO(
+ "mysql:host=localhost;dbname=projweb;charset=utf8", // penser à modifier le nom de l'hébergeur et de la base
+ "root", // ainsi que l'identifiant
+ "" // et le mot de passe
+ );
+ }
+
+ public function __call($method, array $arg) { // méthode magique qui permet d'exécuter un bloc dans le cas où on appellerait une métohde qui n'est pas définie dans Database
+ // $method = le nom de la méthode appelée, array $arg = arguments passés à la méthode, dans un tableau (sans le array, chaîne de caratère avec les arguments séparés par une virgule
+
+ return call_user_func_array(array($this->_db, $method), $arg); // appel de la méthode $methdod de l'objet $this->_db avec comme arguments $arg
+ }
+}
diff --git a/app/kernel/Kernel.php b/app/kernel/Kernel.php
new file mode 100644
index 0000000000000000000000000000000000000000..740a2a55c6dd5566509b4ed6283a984c60a172e0
--- /dev/null
+++ b/app/kernel/Kernel.php
@@ -0,0 +1,40 @@
+<?php
+
+class Kernel { // création d'une classe PHP qui servira à la gestion des modèles, vues et contrôleurs, selon la requête fournie
+
+ public static function autoload($class) { // méthode qui charge automatiquement un fichier en fonction du nom de la classe passé en paramètre
+ if(file_exists(ROOT."/app/kernel/$class.php")) { // 1. on vérifie si le fichier voulu existe dans le répertoire contenant les fichiers de classe du noyau
+ require_once(ROOT."/app/kernel/$class.php"); // si c'est le cas, on l'inclut ici et on finit l'exécution de la fonction
+ }
+ else if(file_exists(ROOT."/app/controller/$class.php")) { // 2. sinon, on fait pareil dans le répertoire contenant les fichiers de contrôleurs
+ require_once(ROOT."/app/controller/$class.php"); // si c'est le cas, on l'inclut ici et on finit l'exécution de la fonction
+ }
+ else if(file_exists(ROOT."/app/model/$class.php")) { // 3. sinon, on fait pareil dans le répertoire contenant les fichiers de modèles
+ require_once(ROOT."/app/model/$class.php"); // si c'est le cas, on l'inclut ici et on finit l'exécution de la fonction
+ }
+ // si aucun fichier n'a été trouvé, on ne fait rien
+ }
+
+
+ public static function run() { // méthode, appelée pour toute requête de page, qui gère les différents fichiers à appeler
+ // 1. on commence par enregistrer notre autoload, afin que PHP sache quoi utiliser pour chercher les fichiers et classes dont on aura besoin plus tard
+ spl_autoload_register(array("Kernel", "autoload")); // on donne dans un tableau la classe qui contient la méthode d'autoload, et le nom de cette méthode (parce qu'on aurait pu lui donner un nom exotique, genre choucroute...)
+
+ // 2. on analyse la requete
+ $query = isset($_GET["query"]) ? $_GET["query"] : ""; // ternaire. Si la variable $_GET['query'] existe, alors on met sa valeur dans la varaible $query. Sinon, on y met la chaîne vide "".
+ $route = Router::analyze($query); // on récupère dans un tableau le nom du contrôleur à utiliser, l'action à déclencher dans ce contrôleur, et les paramètres qui restent dans la requête.
+ // Remarque : ici, on a fait appel à la méthode analyze() de la classe Router, pourtant on n'a pas dit à PHP où la trouver. C'est l'intérêt de l'autoload : à chaque fois que PHP tombe sur une classe qu'il n'a pas en mémoire, il va demander à l'autoload de lui indiquer où la trouver pour l'inclure. Et ça se fait automatiquement ! Elle est pas belle la vie ? :-)
+
+ // 3. on instancie (enfin) le contrôleur adéquat, et on execute l'action demandée
+ $class = $route["controller"]."Controller"; // variable contenant le nom de la classe qu'on va instancier. Il s'agit du nom du contrôleur donné par la méthode analyze() de Router, concaténé avec "Controller". C'est une contrainte qu'on se donne pour nommer les fichiers de façon uniforme.
+ if(class_exists($class)) { // on regarde si la classe en question a été définie (va normalement appeler autoload pour essayer de la charger le cas échéant), et si c'est le cas :
+ $controller = new $class($route); // on instancie la classe
+ $method = array($controller, $route["action"]); // on définit une variable method qui contient le contrôleur fraichement instancié et l'action à effectuer
+ if(is_callable($method)) { // si la méthode existe et peut être appelée
+ call_user_func($method); // alors on appelle la méthode du contrôleur avec l'action souhaitée
+ }
+ // il faudra gérer les erreurs : faire une méthode dédiée dans le noyau à appeler ?
+ // else { error_callable('method'); } ?
+ }
+ }
+}
diff --git a/app/kernel/Model.php b/app/kernel/Model.php
new file mode 100644
index 0000000000000000000000000000000000000000..7c27e9426ba398f7204efebb9b7e410b10013055
--- /dev/null
+++ b/app/kernel/Model.php
@@ -0,0 +1,5 @@
+<?php
+
+class Model { // classe abstraite pour les modèles. Y'a rien dedans, c'est normal, chaque modèle a ses propres trucs à lui... Mais bon, on voulait quand même une classe abstraite pour tout ce petit monde. Et puis qui sait, peut-être que finalement on trouvera des trucs communs à tous les modèles, et là on sera bien contents d'avoir fait une classe mère, hein ! :-P
+
+}
diff --git a/app/kernel/Router.php b/app/kernel/Router.php
new file mode 100644
index 0000000000000000000000000000000000000000..94551ec06257ba7957efcc0d1a2b26888e129495
--- /dev/null
+++ b/app/kernel/Router.php
@@ -0,0 +1,53 @@
+<?php
+
+class Router { // classe PHP permettant l'analyse de l'URL des requêtes
+ public static function analyze($query) { // méthode d'analyse de la requête
+ // on définit une variable, par défaut initialisée sur les paramètres de page d'erreur 404 (page non trouvée)
+ $result = array(
+ "controller" => "Error", // le nom du contrôleur à instancier
+ "action" => "error404", // le nom de l'action à effectuer, autrement dit de la méthode à appeler dans ce contrôleur
+ "params" => array() // les paramètres de la requête (dans un tableau), par défaut aucun
+ );
+
+ if($query === "" || $query === "/") { // on regarde si la requête est identique (===) à la chaîne vide ou "/", et si oui, c'est qu'on voulait accéder à la page d'accueil
+ $result["controller"] = "Index"; // le contrôleur est donc Index
+ $result["action"] = "display"; // on va afficher la page, l'action est donc display
+ // il n'y a pas de paramètres, donc pas d'affectation de "params"
+ }
+ else { // sinon, on a des infos sur la page demandée
+ $parts = explode("/", $query); // on sépare la requête selon les /, et on regarde ce qu'on connait comme ordres dedans
+ if($parts[0] == "jeu" && count($parts) == 2) { // on veut consulter la fiche d'un jeu
+ $result["controller"] = "Jeu"; // le contrôleur à instancier sera "JeuController", on met donc "Jeu" dans la variable de résultat
+ $result["action"] = "display"; // on veut afficher les informations d'un jeu, donc on donne l'action "display"
+ $result["params"]["slug"] = $parts[1]; //on a des paramètres dans l'URL (normalement le nom/id du jeu), on le stocke aussi
+ }
+ else if($parts[0] == "listejeux") { // on veut consulter la liste des jeux
+ $result["controller"] = "Jeu"; // le contrôleur à instancier sera "JeuController", on met donc "Jeu" dans la variable de résultat
+ $result["action"] = "displayListe"; // on veut afficher la liste des jeux, donc on donne l'action "displayListe"
+ // il n'y a pas de paramètres attendus, on n'affecte pas $result["params"]
+ }
+ else if($parts[0] == "profil" && count($parts) == 2) { // autre possibilité : on veut consulter un profil (le premier bout de la requête est "profil", et on a au moins un paramètre derrière)
+ $result["controller"] = "Profil"; // le contrôleur à instancier sera "ProfilController", on met donc "Profil" dans la variable de résultat
+ $result["action"] = "display"; // on veut afficher le profil de quelqu'un, donc on donne l'action "display"
+ $result["params"]["slug"] = $parts[1]; //on a des paramètres dans l'URL (normalement le pseudo de la personne), on le stocke aussi
+ }
+ else if($parts[0] == "classement" && count($parts) > 1) { // autre possibilité : on veut consulter un profil (le premier bout de la requête est "profil", et on a au moins un paramètre derrière)
+ $result["controller"] = "Classement"; // le contrôleur à instancier sera "ProfilController", on met donc "Profil" dans la variable de résultat
+ $result["action"] = "display"; // on veut afficher le profil de quelqu'un, donc on donne l'action "display"
+ $result["params"]["slug"] = $parts[1]; //on a des paramètres dans l'URL (normalement le pseudo de la personne), on le stocke aussi
+ for($k=2; $k<count($parts); $k++) {
+ $result["params"]["slug"] = $result["params"]["slug"].'/'.$parts[$k];
+ }
+ }
+ else if($parts[0] == "connexion" && count($parts) == 1) { // formulaire de connexion
+ $result["controller"] = "Connexion"; // le contrôleur à instancier sera "ProfilController", on met donc "Profil" dans la variable de résultat
+ $result["action"] = "displayForm"; // "displayForm" pour afficher le formulaire
+
+ }
+ // à chaque fois qu'on crée une nouvelle page, il faut rajouter un cas à cet endroit !
+
+ // si on n'a rien trouvé que l'on connaissait, alors la page demandée n'existe pas => erreur 404. Ça tombe bien, c'est comme ça qu'on a initialisé la variable ! :-D
+ }
+ return $result; // on renvoie le tableau avec les informations nécessaires pour savoir quoi faire
+ }
+}
diff --git a/app/kernel/View.php b/app/kernel/View.php
new file mode 100644
index 0000000000000000000000000000000000000000..65c48bef3086f2660d4fbde60f864e7a3d641327
--- /dev/null
+++ b/app/kernel/View.php
@@ -0,0 +1,29 @@
+<?php
+
+class View { // classe abstraite pour les vues
+ protected $_route; // variable protégée contenant le résultat de l'analyse de la requête (dans un tableau)
+ protected $data = array(); // variable protégée contenant des données, sous forme de tableau
+
+ public function __construct($route) { // le constructeur
+ $this->_route = $route; // on stocke la route donnée en paramètre dans la variable protégée $_route
+ }
+
+ public function display() { // va générer un affichage en fonction des paramètres de la route
+ $viewFile = ROOT . "/app/view/" . $this->_route["controller"] . "/" . $this->_route["action"] . ".html"; // on va chercher la vue dans app/view/le_nom_du_contrôleur/ce_qu_on_veut_faire.html (le *.html est là pour indiquer qu'aucun calcul n'est réalisé dans ces pages, qu'elles n'ont qu'une fonction d'affichage. Mais on pourra utiliser du PHP pour afficher des noms de variables (<?php echo $this->profil->pseudo; ? >)
+
+ if(file_exists($viewFile)) { // le fichier existe bel et bien, on peut l'inclure
+ include($viewFile);
+ }
+ else { // le fichier n'existe pas, on lève une exception avec un message d'erreur/excuse
+ throw new DomainException("Vue introuvable - " . $viewFile);
+ }
+ }
+
+ public function __set($key, $value) { // méthode magique permettant de mettre une valeur à un attribut donné, de façon identique pour tous les attributs. Cela évite de devoir définir 15000 setters pour toutes les variables. PHP le fait automatiquement, si c'est pas gentil ça ! ^^
+ $this->data[$key] = $value;
+ }
+
+ public function __get($key) { // idem, mais pour les getters. :-)
+ return $this->data[$key];
+ }
+}
diff --git a/app/model/Classement.php b/app/model/Classement.php
new file mode 100644
index 0000000000000000000000000000000000000000..4cc006b2afb0ec76132a14c37b741395272782f2
--- /dev/null
+++ b/app/model/Classement.php
@@ -0,0 +1,25 @@
+<?php
+
+class Classement extends Model { // classe de modèle pour l'affichage de classements
+ public $classement, $lejeu, $slug; // on définit les attributs de la classe
+
+ public static function getFromSlug($slug) { // méthode permettant de récupérer le classement relatif à un jeu donné de la BDD
+ //$db = Database::getInstance(); // on récupère la connexion à la BDD
+ //$sql = "SELECT * FROM classements WHERE jeu = :slug"; // on définit la requête qu'on enverra (on considère que le slug contient jeu/nomDuJeu pour le classement par jeu. Donc il faudrait encore faire un explode() sur le slug.
+ //$req = $db->prepare($sql); // on prépare la requête (c'est là que la mémthode __call() est utile dans la classe Database d'ailleurs)
+ //$req->setFetchMode(PDO::FETCH_CLASS, "Classement"); // règle le type dans lequel on doit mettre les données (PDO va chercher les attributs de la classe de même nom que ses colonnes de BDD et mettre dedans les valeurs correspondantes)
+ //$req->execute(array(":slug" => $slug)); // on remplace le "::slug" par sa valeur dans la requête
+ //return $req->fetch(); // on retourne le premier (et normalement unique) résultat en BDD
+ return array(array("pseudo"=>"debug","rank"=>$slug), array("pseudo"=>"exemple","rank"=>1), array("pseudo"=>"nestor","rank"=>42));
+ }
+
+ public static function getGlobal() { // méthode permettant de récupérer le classement génaral de la BDD
+ //$db = Database::getInstance(); // on récupère la connexion à la BDD
+ //$sql = "SELECT * FROM classements WHERE jeu = :slug"; // on définit la requête qu'on enverra (on considère que le slug contient jeu/nomDuJeu pour le classement par jeu. Donc il faudrait encore faire un explode() sur le slug.
+ //$req = $db->prepare($sql); // on prépare la requête (c'est là que la mémthode __call() est utile dans la classe Database d'ailleurs)
+ //$req->setFetchMode(PDO::FETCH_CLASS, "Classement"); // règle le type dans lequel on doit mettre les données (PDO va chercher les attributs de la classe de même nom que ses colonnes de BDD et mettre dedans les valeurs correspondantes)
+ //$req->execute(array(":slug" => $slug)); // on remplace le "::slug" par sa valeur dans la requête
+ //return $req->fetch(); // on retourne le premier (et normalement unique) résultat en BDD
+ return array(array("pseudo"=>"debug","rank"=>"gen"), array("pseudo"=>"exemple","rank"=>1), array("pseudo"=>"gimli","rank"=>2), array("pseudo"=>"phoenix","rank"=>3), array("pseudo"=>"table","rank"=>4), array("pseudo"=>"nestor","rank"=>42));
+ }
+}
diff --git a/app/model/Jeu.php b/app/model/Jeu.php
new file mode 100644
index 0000000000000000000000000000000000000000..614dd375e977ba97f3e1fbe4428dc551ba8978ab
--- /dev/null
+++ b/app/model/Jeu.php
@@ -0,0 +1,27 @@
+<?php
+
+class Jeu extends Model {
+ public $id, $nom, $description, $slug;
+
+ public static function getFromSlug($slug) {
+ $db = Database::getInstance();
+ $sql = "SELECT * FROM jeux WHERE slug = :slug";
+ $stmt = $db->prepare($sql);
+ $stmt->setFetchMode(PDO::FETCH_CLASS, "Jeu"); // règle le type dans lequel on doit mettre les données (PDO va chercher les attributs de la classe de même nom que ses colonnes de BDD et mettre dedans les valeurs correspondantes)
+ $stmt->execute(array(":slug" => $slug));
+ return $stmt->fetch();
+ }
+
+ public static function getList() {
+ $db = Database::getInstance();
+ $sql = "SELECT * FROM jeux";
+ $stmt = $db->query($sql);
+ $stmt->setFetchMode(PDO::FETCH_CLASS, "Jeu");
+ return $stmt->fetchAll();
+
+ }
+
+}
+
+
+
diff --git a/app/model/Profil.php b/app/model/Profil.php
new file mode 100644
index 0000000000000000000000000000000000000000..0efe32f5890c581cb890af366f51ecc0443453f6
--- /dev/null
+++ b/app/model/Profil.php
@@ -0,0 +1,25 @@
+<?php
+
+class Profil extends Model { // classe de modèle pour l'affichage de profils
+ public $pseudo, $slug; // on définit les attributs de la classe
+
+ public static function getFromSlug($slug) { // méthode permettant de récupérer les informations relatives à un profil donné de la BDD
+ $db = Database::getInstance(); // on récupère la connexion à la BDD
+ $sql = "SELECT * FROM profils WHERE slug = :slug"; // on définit la requête qu'on enverra
+ $req = $db->prepare($sql); // on prépare la requête (c'est là que la mémthode __call() est utile dans la classe Database d'ailleurs)
+ $req->setFetchMode(PDO::FETCH_CLASS, "Profil"); // règle le type dans lequel on doit mettre les données (PDO va chercher les attributs de la classe de même nom que ses colonnes de BDD et mettre dedans les valeurs correspondantes)
+ $req->execute(array(":slug" => $slug)); // on remplace le "::slug" par sa valeur dans la requête
+ return $req->fetch(); // on retourne le premier (et normalement unique) résultat en BDD
+ }
+
+ public static function getList() { // méthode permettant de récupérer la liste des profils de la BDD
+ $db = Database::getInstance(); // idem à au-dessus
+ $sql = "SELECT * FROM profils";
+ $req = $db->query($sql);
+ $req->setFetchMode(PDO::FETCH_CLASS, "Profil");
+ return $req->fetchAll();
+ }
+}
+
+
+
diff --git a/app/view/classement/display.html b/app/view/classement/display.html
new file mode 100644
index 0000000000000000000000000000000000000000..abccb790f1cf2e0255ee06df653825b4a13842f9
--- /dev/null
+++ b/app/view/classement/display.html
@@ -0,0 +1,27 @@
+<!DOCTYPE html>
+<html>
+<head>
+ <meta charset="utf-8"/>
+ <title>Classement</title>
+ <base href="http://localhost/projet-web-2016/www/"/>
+</head>
+<body>
+ <header>
+ <h1>Page permettant d'afficher un classement, par rapport à un jeu donné.</h1>
+ </header>
+ <h2>On mettra ici le nom du jeu</h2>
+ <p>Et ici la tableau contenant le classement.</p>
+ <p>Mais pour ça on a besoin de savoir quelle est la structure de la base de données... Et on ne la connait pas encore !</p>
+
+ <h2>Classement <?php echo $this->lejeu; ?></h2>
+ <table style="border:1px solid black;border-collapse:collapse;text-align:center;">
+ <tr><th>Pseudo</th><th>Rang</th></tr>
+ <?php foreach($this->classement as $courant) : ?>
+ <tr><td style="border:1px solid black;padding:0 4px 0 4px;"><?php echo $courant['pseudo'];?></td><td style="border:1px solid black;"><?php echo $courant['rank'];?></td></tr>
+ <?php endforeach;?>
+ </table>
+ <footer>
+ <p>Le pied de page</p>
+ </footer>
+</body>
+</html>
diff --git a/app/view/index/display.html b/app/view/index/display.html
new file mode 100644
index 0000000000000000000000000000000000000000..942564c3aaa0c6d367c71f75b2448b20b5263b03
--- /dev/null
+++ b/app/view/index/display.html
@@ -0,0 +1,41 @@
+<!DOCTYPE html>
+<html>
+<head>
+ <meta charset="utf-8"/>
+ <title>Titre de la page d'index du site de classement de jeux de plateaux pour le projet web ENSIIE 2016, et ce titre est beaucoup trop long !</title>
+ <base href="http://localhost/projet-web-2016/www/"/>
+</head>
+<body>
+ <header>
+ <h1>Exemple de page d'accueil</h1>
+ </header>
+ <h2>On peut faire plein de trucs avec ça !</h2>
+
+ <h2 style="margin-bottom:-2px;"><a href="listejeux">Liste de jeux</a></h2>
+ <em>(modifs à venir lorsqu'on aura défini la BDD)</em>
+ <ul>
+ <?php foreach($this->list as $jeu) : ?>
+ <li><a href="jeu/<?php echo $jeu->slug;?>"><?php echo $jeu->nom;?></a></li>
+ <?php endforeach;?>
+ </ul>
+
+ <h2 style="margin-bottom:-4px;">Liste de profils</h2>
+ <em>(modifs à venir lorsqu'on aura défini la BDD)</em>
+ <ul>
+ <?php foreach($this->listprofils as $profil) : ?>
+ <li><a href="profil/<?php echo $profil->slug;?>">Voir le profil de <?php echo $profil->pseudo;?></a></li>
+ <?php endforeach;?>
+ </ul>
+
+ <h2 style="margin-bottom:-4px;">Classements</h2>
+ <em>(modifs à venir lorsqu'on aura défini la BDD)</em>
+ <ul>
+ <li><a href="classement/global/">Classement global</a></li>
+ <li><a href="classement/jeu/random">Classement pour un jeu spécifique</a></li>
+ </ul>
+
+ <footer>
+ <p>Pied de page...</p>
+ </footer>
+</body>
+</html>
diff --git a/app/view/jeu/display.html b/app/view/jeu/display.html
new file mode 100644
index 0000000000000000000000000000000000000000..4fdaaac0a9dfaf3a55a835ce1dc8173946d097f0
--- /dev/null
+++ b/app/view/jeu/display.html
@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html>
+<head>
+ <meta charset="utf-8"/>
+ <title>Fiche d'un jeu</title>
+ <base href="http://localhost/projet-web-2016/www/"/>
+</head>
+<body>
+ <header>
+ <h1>Fiche du jeu <?php echo $this->jeu->nom; ?></h1>
+ </header>
+ <p><em>Description : </em><?php echo $this->jeu->description; ?></p>
+ <footer>
+ <p>Pied de page...</p>
+ </footer>
+</body>
+
+
+</html>
diff --git a/app/view/jeu/displayListe.html b/app/view/jeu/displayListe.html
new file mode 100644
index 0000000000000000000000000000000000000000..7babd344b39a5745e531e66c90ac05023a00fcff
--- /dev/null
+++ b/app/view/jeu/displayListe.html
@@ -0,0 +1,23 @@
+<!DOCTYPE html>
+<html>
+<head>
+ <meta charset="utf-8"/>
+ <title>Liste des jeux</title>
+ <base href="http://localhost/projet-web-2016/www/"/>
+</head>
+<body>
+ <header>
+ <h1>La liste de nos jeux</h1>
+ </header>
+ <ul>
+ <?php foreach($this->liste as $jeu) : ?>
+ <li><a href="jeu/<?php echo $jeu->slug;?>"><?php echo $jeu->nom;?></a></li>
+ <?php endforeach;?>
+ </ul>
+ <footer>
+ <p>Pied de page...</p>
+ </footer>
+</body>
+
+
+</html>
diff --git a/app/view/profil/display.html b/app/view/profil/display.html
new file mode 100644
index 0000000000000000000000000000000000000000..19619ccaad38ed45366ce09d1997a329c132491c
--- /dev/null
+++ b/app/view/profil/display.html
@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html>
+<head>
+ <meta charset="utf-8"/>
+ <title>Exemple de profil</title>
+ <base href="http://localhost/projet-web-2016/www/"/>
+</head>
+<body>
+ <header>
+ <h1>Affichage d'un profil</h1>
+ </header>
+ <h2>Voici le profil de quelqu'un</h2>
+ <h3>Il s'agit du profil de <?php echo $this->profil->pseudo; ?></h3>
+ <p>Et on dit "Bonjour <?php echo $this->profil->pseudo; ?> ! :o)</p>
+ <p>Il a été appelé avec le slug : <?php echo $this->profil->slug; ?></p>
+ <footer>
+ <p>Le pied de page</p>
+ </footer>
+</body>
+</html>
diff --git a/projweb.sql b/projweb.sql
new file mode 100644
index 0000000000000000000000000000000000000000..ce73c386fa7e7ac74bb49a6cde03979388c43d2e
--- /dev/null
+++ b/projweb.sql
@@ -0,0 +1,69 @@
+-- phpMyAdmin SQL Dump
+-- version 4.5.2
+-- http://www.phpmyadmin.net
+--
+-- Client : 127.0.0.1
+-- Généré le : Jeu 31 Mars 2016 à 18:43
+-- Version du serveur : 5.7.9
+-- Version de PHP : 7.0.0
+
+SET SQL_MODE = "NO_AUTO_VALUE_ON_ZERO";
+SET time_zone = "+00:00";
+
+
+/*!40101 SET @OLD_CHARACTER_SET_CLIENT=@@CHARACTER_SET_CLIENT */;
+/*!40101 SET @OLD_CHARACTER_SET_RESULTS=@@CHARACTER_SET_RESULTS */;
+/*!40101 SET @OLD_COLLATION_CONNECTION=@@COLLATION_CONNECTION */;
+/*!40101 SET NAMES utf8mb4 */;
+
+--
+-- Base de données : `projweb`
+--
+
+-- --------------------------------------------------------
+
+--
+-- Structure de la table `jeux`
+--
+
+DROP TABLE IF EXISTS `jeux`;
+CREATE TABLE IF NOT EXISTS `jeux` (
+ `id` int(11) NOT NULL AUTO_INCREMENT,
+ `nom` varchar(150) NOT NULL,
+ `description` varchar(250) NOT NULL,
+ `slug` varchar(32) NOT NULL,
+ PRIMARY KEY (`id`)
+) ENGINE=InnoDB AUTO_INCREMENT=3 DEFAULT CHARSET=utf8;
+
+--
+-- Contenu de la table `jeux`
+--
+
+INSERT INTO `jeux` (`id`, `nom`, `description`, `slug`) VALUES
+(1, 'Rencontre Cosmique', 'Jeu de plateau de 3 Ã 5 joueurs', 'rencontre-cosmique'),
+(2, 'Echec', 'Jeu de plateau de 2 joueurs', 'echec');
+
+-- --------------------------------------------------------
+
+--
+-- Structure de la table `profils`
+--
+
+DROP TABLE IF EXISTS `profils`;
+CREATE TABLE IF NOT EXISTS `profils` (
+ `slug` varchar(80) NOT NULL,
+ `pseudo` varchar(120) NOT NULL,
+ PRIMARY KEY (`slug`)
+) ENGINE=MyISAM DEFAULT CHARSET=utf8;
+
+--
+-- Contenu de la table `profils`
+--
+
+INSERT INTO `profils` (`slug`, `pseudo`) VALUES
+('nestor', 'Nestor'),
+('test', 'Un pseudo de test');
+
+/*!40101 SET CHARACTER_SET_CLIENT=@OLD_CHARACTER_SET_CLIENT */;
+/*!40101 SET CHARACTER_SET_RESULTS=@OLD_CHARACTER_SET_RESULTS */;
+/*!40101 SET COLLATION_CONNECTION=@OLD_COLLATION_CONNECTION */;
diff --git a/readme.md b/readme.md
index e54d04294e04eedc93feabf1e9897ead301d99ea..21fca5e3309f18ea2f44a4fba79ef441d1ae9b6f 100644
--- a/readme.md
+++ b/readme.md
@@ -1,5 +1,17 @@
Projet Web 2016 - Classement multi-jeux de plateau
==================================================
+Membres du groupe
+-----------------
+
+* Vincent *Nestor* BOCHET (4.2)
+* Romain *Table* DROUIN (3.1)
+* Eliah *Phoenix* REBSTOCK (4.1)
+* Guillaume *Gimli* SEZILLE (4.1)
+
+Random infos
+------------
+
+* Palette de couleur préliminaire : http://paletton.com/#uid=53l0x1knDk8atANhJqsuvcSJX5xknDk8atANhJqsuvcSJX5xkrDorewC+lIt2vBijKN9X
diff --git a/www/.htaccess b/www/.htaccess
new file mode 100644
index 0000000000000000000000000000000000000000..090c07c8ec3d19afd7ad501efb996f5eb6ca651d
--- /dev/null
+++ b/www/.htaccess
@@ -0,0 +1,11 @@
+# Mise en place de la ré-écriture
+Options +FollowSymLinks
+RewriteEngine On
+
+# Adresse de base de réécriture, dépendante de l'architecture, et donc à modifier à chaque installation du site...
+RewriteBase /projet-web-2016/www
+
+# Règles de réécriture des URL
+RewriteCond %{SCRIPT_FILENAME} !-f
+RewriteCond %{SCRIPT_FILENAME} !-d
+RewriteRule (.*) index.php?query=$1 [QSA,L]
diff --git a/www/index.php b/www/index.php
new file mode 100644
index 0000000000000000000000000000000000000000..d51346b319185fb2eede1d174cd4a593f1186aef
--- /dev/null
+++ b/www/index.php
@@ -0,0 +1,17 @@
+<?php
+//
+// Info :
+// Penser à éditer la ligne "RewriteBase" du fichier .htaccess si besoin.
+//
+//
+// Ce fichier est le point d'entrée unique du projet. Toute requête de page sera envoyée sur cette page, qui s'occupera d'appeler les fichiers nécessaires.
+// La requête client se trouve dans le paramètre query.
+//
+// => pour le debug : echo $_GET["query"]; die(); (affiche le contenu de $_GET['query'] et termine l'exécution)
+//
+
+define("ROOT", realpath(__dir__."/..")); // on définit une sorte de variable globale, nommée ROOT, qui contient le répertoire racine de notre site. On s'en servira par la suite lorsque l'on voudra accéder à tel ou tel fichier (vue, contrôleur, modèle ou autre...
+
+require_once(ROOT . "/app/kernel/Kernel.php"); // première chose à faire : on inclut le fichier noyau, qui va gérer les différentes actions à effectuer (trouver quelle page est demandée, quel contrôleur appeler, quelle vue afficher, etc.)
+
+Kernel::run(); // deuxième chose : on lance la méthode run() de la classe Kernel. (oui, c'est de l'objet.)