final

2016-05-10 00:03:02 +02:00
parent 9ff93fae99
commit 4dfde3d966
26 changed files with 1728 additions and 284 deletions
--- a/bin/hex
+++ b/bin/hex
--- a/2
+++ b/2
@@ -5,7 +5,7 @@ LDFLAGS=-std=c99 -lm `sdl-config --cflags --libs` -lSDL_ttf -lSDL_gfx -lSDL_mixe
 EXEC=bin/hex
 SRCDIR=src
 OBJDIR=obj
-SRC=hex.c affichage_plateau.c action_plateau.c affichage_menu_principal.c window.c param.c en_jeu.c menu_principal.c draw.c action_menu_principal.c sound.c testJeu.c sauvegarde.c scrolling.c
+SRC=hex.c affichage_plateau.c action_plateau.c affichage_menu.c window.c param.c en_jeu.c menu_principal.c draw.c action_menu.c sound.c testJeu.c sauvegarde.c scrolling.c menu.c menu_en_jeu.c sub_menu.c
 #$(wildcard src/*.c)
 OBJ=$(SRC:.c=.o)

--- a/src/action_menu.c
+++ b/src/action_menu.c
@@ -0,0 +1,217 @@
+/*
+ * action_menu_principal.c
+ *
+ *  Created on: 21 avr. 2016
+ *      Author: nathan
+ */
+
+#include "action_menu.h"
+
+#include <math.h>
+#include <SDL/SDL_image.h>
+#include <SDL/SDL_mixer.h>
+#include <SDL/SDL_rotozoom.h>
+
+#include "affichage_menu.h"
+#include "globals.h"
+#include "sound.h"
+
+void deplacement_menu_mouse (menu_t m, const SDL_Event* event)
+{
+	vec2 pos = {event->motion.x - m->pos.x + m->l/2 - m->r, event->motion.y - m->pos.y};
+	int ligne =  round(pos.y / (1.5 * m->r) - .5);
+	int colone = round(pos.x / (m->l + 1.) - .5);
+	vec2 relative = {pos.x % (m->l + 1), pos.y % (int)(1.5 * m->r)};
+	vec2 proj = {relative.y + relative.x / RAC3, relative.y - relative.x / RAC3};
+	vec2 hex;
+
+	if (ligne % 2)
+	{
+		if (proj.y < 0 && proj.x < m->r)
+		{
+			/* haut */
+			hex.y = ligne - 1;
+			hex.x = colone - ligne / 2;
+		}
+		else if (relative.x > m->l / 2)
+		{
+			/* bas droite */
+			hex.y = ligne;
+			hex.x = colone - ligne / 2;
+		}
+		else
+		{
+			/* bas gauche */
+			hex.y = ligne;
+			hex.x = colone - ligne / 2 - 1;
+		}
+	}
+	else
+	{
+		if (-proj.y > m->r/2)
+		{
+			/* haut droite */
+			hex.y = ligne - 1;
+			hex.x = colone - ligne / 2 + 1;
+		}
+		else if (proj.x < m->r/2)
+		{
+			/* haut gauche */
+			hex.y = ligne - 1;
+			hex.x = colone - ligne / 2;
+		}
+		else
+		{
+			/* bas */
+			hex.y = ligne;
+			hex.x = colone - ligne / 2;
+		}
+	}
+
+	if (0 > hex.x || hex.x >= 3 || 0 > hex.y || hex.y >= 3  || (hex.x != 1 && hex.y != 1))
+	{
+		hex.x = 1;
+		hex.y = 1;
+	}
+	if (hex.x != m->cur.x || hex.y != m->cur.y)
+	{
+		Affiche_entry(m, NORMAL);
+		m->cur.x = hex.x;
+		m->cur.y = hex.y;
+		Affiche_entry(m, POINTE);
+		play_clik();
+	}
+}
+
+void deplacement_menu_key (menu_t m, SDLKey key)
+{
+	Affiche_entry(m, NORMAL);
+	switch (key)
+	{
+	case SDLK_RIGHT:
+		++(m->cur.x);
+		if (m->cur.y != 1)
+			m->cur.y = 1;
+		break;
+	case SDLK_LEFT:
+		--(m->cur.x);
+		if (m->cur.y != 1)
+			m->cur.y = 1;
+		break;
+	case SDLK_UP:
+		--(m->cur.y);
+		if (m->cur.x != 1)
+			m->cur.x = 1;
+		break;
+	case SDLK_DOWN:
+		++(m->cur.y);
+		if (m->cur.x != 1)
+			m->cur.x = 1;
+		break;
+	default:
+		break;
+	}
+	if (m->cur.x >= 3)
+		m->cur.x = 0;
+	if (m->cur.x < 0)
+		m->cur.x = 2;
+	if (m->cur.y >= 3)
+		m->cur.y = 0;
+	if (m->cur.y < 0)
+		m->cur.y = 2;
+	Affiche_entry(m, POINTE);
+	play_clik();
+}
+
+void boom (SDL_Surface* window)
+{
+	SDL_Surface* tmp = IMG_Load ("ressources/.east/Boom.png");
+	SDL_Surface* boom = rotozoomSurface(tmp, .0, fmin(window->h / (float)tmp->h, window->w / (float)tmp->w), 1);
+	SDL_Rect p = {(window->w - boom->w) / 2, (window->h - boom->h) / 2};
+	SDL_Surface* lum = SDL_CreateRGBSurface (SDL_HWSURFACE, window->w, window->h, window->format->BitsPerPixel, 0, 0, 0, 0);
+
+	SDL_FreeSurface(tmp);
+	tmp = SDL_CreateRGBSurface (SDL_HWSURFACE, window->w, window->h, window->format->BitsPerPixel, 0, 0, 0, 0);
+	SDL_BlitSurface (window, NULL, tmp, NULL);
+
+	Mix_Chunk* boomS = Mix_LoadWAV("ressources/.east/Boom.wav");
+	Mix_VolumeChunk (boomS, .1 * MIX_MAX_VOLUME);
+	if (boomS == NULL)
+		fprintf (stderr, "ressources/.east/Boom.mp3 : %s\n", SDL_GetError());
+	Mix_PlayChannel(0, boomS, 0);
+
+	bool end = false;
+
+	int i = 255;
+	while (i >= 0)
+	{
+		if (!(SDL_GetTicks() % 40))
+		{
+			SDL_FillRect (window, NULL, SDL_MapRGB (window->format, 0, 0, 0));
+
+			SDL_BlitSurface (boom, NULL, window, &p);
+
+			Uint32 white = SDL_MapRGB (window->format, 255, 255, 255);
+			SDL_FillRect (lum, NULL, white);
+			SDL_SetAlpha(lum, SDL_SRCALPHA, i);
+			SDL_BlitSurface (lum, NULL, window, NULL);
+			SDL_Flip (window);
+			i -= 4;
+		}
+	}
+
+	Uint32 black = SDL_MapRGB (window->format, 0, 0, 0);
+	SDL_FillRect (lum, NULL, black);
+	SDL_SetAlpha(lum, SDL_SRCALPHA, 1);
+
+	while (i < 256)
+	{
+		if (!(SDL_GetTicks() % 10))
+		{
+			SDL_BlitSurface (lum, NULL, window, NULL);
+			SDL_Flip (window);
+			i += 1;
+		}
+	}
+
+	while (!end)
+	{
+		SDL_Event e;
+		SDL_PollEvent (&e);
+		if (e.type == SDL_QUIT || (e.type == SDL_KEYDOWN && e.key.keysym.sym == SDLK_ESCAPE))
+			end = true;
+	}
+
+	SDL_BlitSurface (tmp, NULL, window, NULL);
+
+	SDL_FreeSurface(tmp);
+	SDL_FreeSurface(boom);
+	SDL_FreeSurface(lum);
+	Mix_FreeChunk (boomS);
+}
+
+int selection_menu (menu_t m)
+{
+	switch (10 * m->cur.x + m->cur.y)
+	{
+	case 01:
+		return M_LEFT;
+	case 10:
+		return M_UP;
+	case 11:
+		if (m->c == 15)
+		{
+			boom (m->window);
+			m->c = 0;
+		}
+		else
+			++m->c;
+		return M_MID;
+	case 12:
+		return M_DOWN;
+	case 21:
+		return M_RIGHT;
+	default:
+		return M_NOT;
+	}
+}
--- a/src/action_menu.h
+++ b/src/action_menu.h
@@ -0,0 +1,21 @@
+/*
+ * action_menu_principal.h
+ *
+ *  Created on: 21 avr. 2016
+ *      Author: nathan
+ */
+
+#ifndef _ACTION_MENU_PRINCIPAL_H_
+#define _ACTION_MENU_PRINCIPAL_H_
+
+#include <SDL/SDL.h>
+#include <stdbool.h>
+#include "globals.h"
+
+void deplacement_menu_mouse (menu_t m, const SDL_Event* event);
+
+void deplacement_menu_key (menu_t m, SDLKey key);
+
+int selection_menu (menu_t m);
+
+#endif /* _ACTION_MENU_PRINCIPAL_H_ */
--- a/src/action_plateau.c
+++ b/src/action_plateau.c
@@ -18,8 +18,8 @@ int selection (plateau_t p, curseur_t c)
 		p->player = !p->player;
 		Affiche_hexagon(p, c.x, c.y, PLAYER(p->player));
 		return testGagne (p->grid, PLAYER(!p->player));
-	}
-	/*for (int x = 0; x < NBSIDE; ++x)
+	}/*
+	for (int x = 0; x < NBSIDE; ++x)
 	{
 			for (int y = 0; y < NBSIDE; ++y)
 				printf ("%d ", p->hist [y * NBSIDE + x]);
@@ -30,13 +30,9 @@ int selection (plateau_t p, curseur_t c)
 	return 0;
 }

-void deplacement (plateau_t p, SDL_Event* event, curseur_t* c)
+void deplacement_mouse (plateau_t p, SDL_MouseMotionEvent motion, curseur_t* c)
 {
-	switch (event->type)
-	{
-	case SDL_MOUSEMOTION:
-	{
-		vec2 pos = {event->motion.x - (p->marge_hori + p->r - p->l/2 - 2), event->motion.y - (p->marge_vert  + 1)};
+	vec2 pos = {motion.x - (p->marge_hori + p->r - p->l/2 - 2), motion.y - (p->marge_vert  + 1)};
 	int ligne =  round(pos.y / (1.5 * p->r) - .5);
 	int colone = round(pos.x / (p->l + 1.) - .5);
 	vec2 relative = {pos.x % (p->l + 1), pos.y % (int)(1.5 * p->r)};
@@ -99,17 +95,13 @@ void deplacement (plateau_t p, SDL_Event* event, curseur_t* c)
 		}

 	}
-
-
-
-		break;
 }
-	case SDL_KEYDOWN:
-		while (!SDL_PollEvent(event))
+
+void deplacement_key (plateau_t p, SDLKey key, curseur_t* c)
 {
 	if (0 <= c->x && c->x < NBSIDE && 0 <= c->y && c->y < NBSIDE)
 		Affiche_hexagon(p, c->x, c->y, NORMAL);
-			switch (event->key.keysym.sym)
+	switch (key)
 	{
 	case SDLK_RIGHT:
 		++(c->x);
@@ -136,9 +128,4 @@ void deplacement (plateau_t p, SDL_Event* event, curseur_t* c)
 		c->y = NBSIDE - 1;
 	Affiche_hexagon(p, c->x, c->y, PLAYER(p->player));
 	play_clik();
-			SDL_Delay (100);
-		}
-		break;
-	}
-
 }
--- a/src/action_plateau.h
+++ b/src/action_plateau.h
@@ -7,6 +7,8 @@

 int selection (plateau_t p, curseur_t c);

-void deplacement (plateau_t p, SDL_Event* event, curseur_t* c);
+void deplacement_mouse (plateau_t p, SDL_MouseMotionEvent motion, curseur_t* c);
+
+void deplacement_key (plateau_t p, SDLKey key, curseur_t* c);

 #endif /* _ACTION_PLATEAU_H_ */
--- a/src/affichage_menu.c
+++ b/src/affichage_menu.c
@@ -0,0 +1,387 @@
+#include "affichage_menu.h"
+
+#include <SDL/SDL.h>
+#include <SDL/SDL_ttf.h>
+#include <SDL/SDL_rotozoom.h>
+#include <SDL/SDL_image.h>
+#include <assert.h>
+#include "param.h"
+#include "draw.h"
+
+#define NBOPTIONS 5
+
+#define LEFT 0
+#define RIGHT 1
+
+
+/* Menu */
+/* Interne */
+
+void Redim_entry (SDL_Surface** entry, int rayon, int l)
+{
+	SDL_Surface* entry_dim;
+	if ((*entry)->h / (float)(*entry)->w < rayon / (float)l)
+		entry_dim = rotozoomSurface(*entry, 0, l/(float)(*entry)->w, 1);
+	else
+		entry_dim = rotozoomSurface(*entry, 0, rayon/(float)(*entry)->h, 1);
+	SDL_FreeSurface (*entry);
+	*entry = entry_dim;
+}
+
+SDL_Surface* Incruste (SDL_Surface* hex, char* title, int l, TTF_Font* font, SDL_Color c)
+{
+	SDL_Surface* hex_entry = SDL_CreateRGBSurface (SDL_HWSURFACE, hex->w, hex->h, hex->format->BitsPerPixel, 0, 0, 0, 0);
+	SDL_BlitSurface (hex, NULL, hex_entry, NULL);
+
+	SDL_Surface* entry = TTF_RenderUTF8_Blended(font, title, c);
+	Redim_entry(&entry, hex->w / 2, l - 20);
+
+	SDL_Rect position = {hex->w / 2 - l / 2 + (l - entry->w) / 2 - 1, hex->w / 2 / 2 + (hex->w / 2 - entry->h) / 2};
+
+	SDL_BlitSurface (entry , NULL, hex_entry, &position);
+	SDL_SetColorKey (hex_entry, SDL_SRCCOLORKEY, SDL_MapRGB(hex->format, 0, 0, 0));
+
+	SDL_FreeSurface (entry);
+	return hex_entry;
+}
+
+
+
+void Case_menu (menu_t m, int rayon)
+{
+	SDL_Color fontColor = {100, 100, 100};
+
+	int l;
+	SDL_Surface* hex = SDL_CreateRGBSurface (SDL_HWSURFACE, 2*rayon, 2*rayon, m->window->format->BitsPerPixel, 0, 0, 0, 0);
+	Hexagon (hex, rayon, param->ex, param->in, 10, &l);
+	int xorig = (m->window->w - 4 * (l + 1)) / 2;
+	/* Charger */
+	int dx =  xorig - rayon + l/2 + 1;
+	SDL_Rect position = {dx + 1 * (l + 1) / 2, 0 + 1 * (1.5 * rayon)};
+	SDL_Surface* hex_entry = Incruste(hex, m->entries [0], l, param->font, fontColor);
+	SDL_BlitSurface (hex_entry, NULL, m->window, &position);
+	SDL_FreeSurface (hex_entry);
+
+	m->l = l;
+	m->r = rayon;
+	m->pos.x = dx;
+	m->pos.y = 0;
+
+	/* Option */
+	dx = xorig + 2 * (l + 1) - rayon + l/2 + 1;
+	position.x = dx + 1 * (l + 1) / 2;
+	hex_entry = Incruste(hex, m->entries [4], l, param->font, fontColor);
+	SDL_BlitSurface (hex_entry, NULL, m->window, &position);
+	SDL_FreeSurface (hex_entry);
+
+	dx = xorig + 1 * (l + 1) - rayon + l/2 + 1;
+	for (int j = 0; j < 3; ++j)
+	{
+		position.x = dx + j * (l + 1) / 2;
+		position.y = 0 + j * (1.5 * rayon);
+		hex_entry = Incruste(hex, m->entries [j+1], l, param->font, fontColor);
+		SDL_BlitSurface (hex_entry, NULL, m->window, &position);
+		SDL_FreeSurface (hex_entry);
+	}
+
+	SDL_FreeSurface(hex);
+}
+
+/* Externes */
+
+void Affiche_menu (menu_t m)
+{
+	int width = m->window->w - 20;
+	int height = m->window->h * 11. / 12;
+
+	int r1 = width / (3 * RAC3);
+	int r2 = height / 5;
+
+	if (r1 < r2)
+		r1 = r1 - r1 % 2;
+	else
+		r1 = r2 - r2 % 2;
+
+	Case_menu (m, r1);
+	Affiche_entry(m, POINTE);
+	SDL_Flip (m->window);
+}
+
+void Affiche_entry (menu_t m, bool pointe)
+{
+	int dx = m->pos.x + m->cur.x * (m->l + 1);
+	SDL_Rect position = {dx + m->cur.y * (m->l + 1) / 2, m->pos.y + m->cur.y * (1.5 * m->r)};
+	SDL_Surface* hex = SDL_CreateRGBSurface (SDL_HWSURFACE, 2*m->r, 2*m->r, m->window->format->BitsPerPixel, 0, 0, 0, 0);
+	SDL_Surface* hex_entry;
+	SDL_Color c;
+	if (pointe)
+	{
+		Hexagon (hex, m->r, param->j1, param->in, 10, &(m->l));
+		c.r = 255; c.g = 0; c.b = 0;
+	}
+	else
+	{
+		Hexagon (hex, m->r, param->ex, param->in, 10, &(m->l));
+		c.r = 100; c.g = 100; c.b = 100;
+	}
+	switch (m->cur.x * 10 + m->cur.y)
+	{
+	case 01:
+		hex_entry = Incruste (hex, m->entries [0], m->l, param->font, c);
+		break;
+	case 10:
+		hex_entry = Incruste (hex, m->entries [1], m->l, param->font, c);
+		break;
+	case 11:
+		hex_entry = Incruste (hex, m->entries [2], m->l, param->font, c);
+		break;
+	case 12:
+		hex_entry = Incruste (hex, m->entries [3], m->l, param->font, c);
+		break;
+	case 21:
+		hex_entry = Incruste (hex, m->entries [4], m->l, param->font, c);
+		break;
+	}
+
+	SDL_FreeSurface (hex);
+	SDL_BlitSurface (hex_entry, NULL, m->window, &position);
+	SDL_FreeSurface (hex_entry);
+	SDL_Flip (m->window);
+}
+
+/* Menu options */
+/* Interne */
+
+/*void print_arrow (SDL_Surface* window, bool side, )
+{
+	SDL_Surface* arrow = SDL_CreateRGBSurface (SDL_HWSURFACE, 2*m->r, 2*m->r, window->format->BitsPerPixel, 0, 0, 0, 0);
+}
+
+SDL_Rect cadre_options (SDL_Surface* window, int l)
+{
+	SDL_Rect pos = {(window->w - 4 * (l + 1)) / 2 + (l + 1) / 2, 0, 2 * l + 1, window->h * 11. /12};
+	SDL_FillRect (window, &pos, param->ex);
+	pos.x += 10;
+	pos.y += 10;
+	pos.w -= 20;
+	pos.h -= 20;
+	SDL_FillRect (window, &pos, param->in);
+	return pos;
+}
+
+int create_options_surfaces (SDL_Surface* entry [NBOPTIONS])
+{
+	char* entry_name [NBOPTIONS] = {"Musique : ", "Son : ", "Couleurs : ", "Taille : ", "Retour"};
+	// Also modify NBOPTIONS
+	int maxw = 0;
+	for (int i = 0; i < NBOPTIONS; ++i)
+	{
+		entry [i] = TTF_RenderUTF8_Blended (param->font, entry_name [i], param->rgb_ex);
+		if (maxw < entry[i]->w)
+			maxw = entry[i]->w;
+	}
+	return maxw;
+}
+
+SDL_Rect blit_redim_options (SDL_Surface* window, SDL_Surface* entry [NBOPTIONS], SDL_Rect pos, int maxw, int size, int margev)
+{
+	for (int i = 0; i < NBOPTIONS - 1; ++i)
+	{
+		SDL_Surface* entry_dim;
+		if (pos.w / 2 < entry[i]->w)
+		{
+			entry_dim = rotozoomSurface(entry[i], 0, pos.w / (2. * maxw), 1);
+			SDL_FreeSurface (entry[i]);
+		}
+		else if (size < entry[i]->h)
+		{
+			entry_dim = rotozoomSurface(entry[i], 0, pos.w / (2. * maxw), 1);
+			SDL_FreeSurface (entry[i]);
+		}
+		else
+			entry_dim = entry[i];
+
+		SDL_Rect pos_entry = {pos.x + (pos.w / 2 - entry_dim->w) / 2, pos.y + (size - entry_dim->h) / 2, 0, 0};
+		SDL_BlitSurface (entry_dim, NULL, window, &pos_entry);
+
+		pos.y += size + margev;
+
+		SDL_FreeSurface (entry_dim);
+	}
+	return pos;
+}
+
+SDL_Rect blit_redim_retour (SDL_Surface* window, SDL_Surface* entry [NBOPTIONS], SDL_Rect pos, int maxw, int size)
+{
+	SDL_Surface* entry_dim;
+	if (pos.w / 2 < entry[NBOPTIONS-1]->w)
+	{
+		entry_dim = rotozoomSurface(entry[NBOPTIONS-1], 0, pos.w / (2. * maxw), 1);
+		SDL_FreeSurface (entry[NBOPTIONS-1]);
+	}
+	else if (size < entry[NBOPTIONS-1]->h)
+	{
+		entry_dim = rotozoomSurface(entry[NBOPTIONS-1], 0, pos.w / (2. * maxw), 1);
+		SDL_FreeSurface (entry[NBOPTIONS-1]);
+	}
+	else
+		entry_dim = entry[NBOPTIONS-1];
+
+	SDL_Rect pos_entry = {pos.x + (pos.w - entry_dim->w)/2 + 10, pos.y + (size - entry_dim->h) / 2, 0, 0};
+	SDL_Rect pos_cadre = {pos_entry.x - 10, pos_entry.y - 10, entry_dim->w + 20, entry_dim->h + 20};
+	SDL_FillRect (window, &pos_cadre, param->ex);
+	pos_cadre.x += 5;
+	pos_cadre.y += 5;
+	pos_cadre.w -= 10;
+	pos_cadre.h -= 10;
+	SDL_FillRect (window, &pos_cadre, param->in);
+	SDL_BlitSurface (entry_dim, NULL, window, &pos_entry);
+
+	SDL_FreeSurface (entry_dim);
+
+	return pos;
+}*/
+
+/* Externe
+
+void Affiche_menu_options (SDL_Surface* window, int rayon, int l)
+{
+	SDL_Surface* hex = SDL_CreateRGBSurface (SDL_HWSURFACE, rayon * 2, rayon * 2, window->format->BitsPerPixel, 0, 0, 0, 0);
+	Hexagon_single (hex, rayon, SDL_MapRGB(hex->format, 0, 0, 0), &l);
+	int dx = (window->w - 4 * (l + 1)) / 2 - rayon + l/2 + 1  + (l + 1);
+	SDL_Rect pos_hex = {dx + 2 * (l + 1) / 2, 2 * (1.5 * rayon)};
+	SDL_BlitSurface (hex, NULL, window, &pos_hex);
+	SDL_FreeSurface (hex);
+
+	SDL_Rect pos = cadre_options (window, l);
+
+	int size = pos.h * 2 / 3. / NBOPTIONS;
+	int margev = pos.h / 3. / (NBOPTIONS + 1);
+
+	pos.y += margev;
+	pos.w -= 40;
+	pos.x += 10;
+
+	SDL_Surface* entry [NBOPTIONS];
+
+	int maxw = create_options_surfaces (entry);
+
+	pos = blit_redim_options (window, entry, pos, maxw, size, margev);
+	pos = blit_redim_retour (window, entry, pos, maxw, size);
+
+	for (int i = 0 ; i < window->h; ++i)
+		putPixel (window, pos.x + pos.w/2 + 10, i, SDL_MapRGB (window->format, 0, 255, 0));
+
+
+	SDL_Flip (window);
+}*/
+
+void banane (SDL_Surface* window)
+{
+	SDL_Surface* gif [8];
+	SDL_Rect p = {0, 0};
+
+	for (int i = 1; i <= 8; ++i)
+	{
+		char dir [254];
+		sprintf (dir, "ressources/.east/Dancing_Banana%d.png", i);
+		SDL_Surface* tmpB = IMG_Load (dir);
+		float ch = window->h / (float)tmpB->h, cw = window->w / (float)tmpB->w;
+		if (cw < ch)
+		{
+			gif [i - 1] = rotozoomSurface(tmpB, .0, cw, 1);
+			p.y = (window->h - gif [i - 1]->h) / 2;
+		}
+		else
+		{
+			gif [i - 1] = rotozoomSurface(tmpB, .0, ch, 1);
+			p.x = (window->w - gif [i - 1]->w) / 2;
+		}
+		SDL_FreeSurface (tmpB);
+	}
+
+	SDL_Surface* erase = SDL_CreateRGBSurface (SDL_HWSURFACE, gif[0]->w, gif[0]->h, window->format->BitsPerPixel, 0, 0, 0, 0);
+	p.w = gif [0]->w;
+	p.h = gif [0]->h;
+	SDL_BlitSurface (window, &p, erase, NULL);
+
+	bool end = false;
+	int i = 0;
+	int cur = 0;
+	char* passcode = "stopdancingstupidbanana";
+	bool pause = false;
+	while (!end)
+	{
+		if (!(SDL_GetTicks() % 100) && !pause)
+		{
+			SDL_BlitSurface (gif [i%8], NULL, window, &p);
+			SDL_Flip (window);
+			SDL_BlitSurface (erase, NULL, window, &p);
+			i = (i + 1) % 8 + 8;
+		}
+		SDL_Event e;
+		if (SDL_PollEvent (&e) && e.type == SDL_KEYDOWN)
+		{
+			switch (e.key.keysym.sym)
+			{
+			case SDLK_p:
+					pause = true;
+					break;
+			case SDLK_r:
+					pause = false;
+					break;
+			default:;
+			}
+			//Uint8* key = SDL_GetKeyState(NULL);
+			if (e.key.keysym.sym == passcode[cur])
+				++cur;
+			else
+				cur = 0;
+			if (cur == strlen (passcode))
+				end = true;
+		}
+	}
+
+	SDL_BlitSurface (erase, NULL, window, &p);
+	SDL_Flip (window);
+
+	for (int i = 0; i < 8; ++i)
+	{
+		SDL_FreeSurface (gif [i]);
+	}
+	SDL_FreeSurface (erase);
+}
+
+void east1 (SDL_Surface* window, SDLKey key)
+{
+	static int banana = 0;
+	switch (key)
+	{
+	case SDLK_a:
+		if (banana % 2)
+			++banana;
+		else
+			banana = 0;
+		break;
+	case SDLK_b:
+		if (banana == 0)
+			++banana;
+		else
+			banana = 0;
+		break;
+	case SDLK_n:
+		if (banana == 2 || banana == 4)
+			++banana;
+		else
+			banana = 0;
+		break;
+	default:
+		banana = 0;
+	}
+
+	if (banana == 6)
+	{
+		banane (window);
+		banana = 0;
+	}
+}
--- a/src/affichage_menu.h
+++ b/src/affichage_menu.h
@@ -0,0 +1,13 @@
+#ifndef _AFFICHAGE_MENU_PRICIPAL_
+#define _AFFICHAGE_MENU_PRICIPAL_ 
+
+#include <SDL/SDL.h>
+#include "globals.h"
+
+void Affiche_menu (menu_t m);
+
+void Affiche_entry (menu_t m, bool pointe);
+
+void east1 (SDL_Surface* window, SDLKey key);
+
+#endif /* _AFFICHAGE_MENU_PRICIPAL_ */
--- a/src/affichage_plateau.c
+++ b/src/affichage_plateau.c
@@ -3,6 +3,7 @@
 #include <math.h>
 #include <stdlib.h>
 #include <SDL/SDL_gfxPrimitives.h>
+#include <SDL/SDL_rotozoom.h>

 #include "draw.h"

@@ -32,7 +33,6 @@ void Define_rayon (plateau_t p)
 		p->marge_hori = (p->window->w - NBSIDE * l - NBSIDE * l / 2) / 2;
 		p->marge_vert = (p->window->h - 1.5 * (NBSIDE) * p->r - p->r / 2) / 2;
 	}
-	printf ("%d - %d - %d\n", p->r, r1, r2);
 }

 void Bordures (plateau_t p)
@@ -131,6 +131,8 @@ void Quadrille (plateau_t p)

 	Bordures (p);

+	Menu_button(p, 0);
+
 	SDL_Flip (p->window);
 }

@@ -172,11 +174,46 @@ void Quadrille_bis (plateau_t p)

 	Bordures (p);

+	Menu_button(p, 0);
+
 	SDL_Flip (p->window);
 }

 /*Externes*/

+void Menu_button (plateau_t p, bool pointe)
+{
+	SDL_Rect pos = {p->marge_hori + (p->window->w - 2 * p->marge_hori) / 48, p->marge_vert + p->r * 1.5 * (NBSIDE - 2) + p->r / 2, .h = (p->window->h - 2 * p->marge_vert) / 9};
+
+	SDL_Surface* tmp;
+	SDL_Color c;
+	if (pointe)
+		if (PLAYER(p->player) == J1)
+			c = param->rgb_j1;
+		else
+			c = param->rgb_j2;
+	else
+		c = param->rgb_ex;
+	tmp = TTF_RenderUTF8_Blended (param->font, "Menu", c);
+	SDL_Surface* menu = rotozoomSurface(tmp, .0, (pos.h - 8) / (float)tmp->h, 1);
+	SDL_FreeSurface (tmp);
+	pos. w = menu->w + 16;
+	SDL_FillRect (p->window, &pos, SDL_MapRGB (p->window->format, c.r, c.g, c. b));
+	pos.w -= 8;
+	pos.h -= 8;
+	pos.x += 4;
+	pos.y += 4;
+	SDL_FillRect (p->window, &pos, param->in);
+	p->menu.x = pos.x;
+	p->menu.y = pos.y;
+	p->menu.w = pos.w;
+	p->menu.h = pos.h;
+	SDL_Rect postxt = {pos.x, pos.y};
+	postxt.x = pos.x + (pos.w - menu->w) / 2;
+	SDL_BlitSurface (menu, NULL, p->window, &postxt);
+	SDL_Flip(p->window);
+}
+
 void Affiche_hexagon (plateau_t p, int x, int y, int state)
 {
 	SDL_Rect position = {p->marge_hori + x * (p->l + 1) + y * (p->l + 1) / 2, p->marge_vert + y * (1.5 * p->r)};
--- a/src/affichage_plateau.h
+++ b/src/affichage_plateau.h
@@ -7,10 +7,10 @@

 #define COLOR 32

-void putPixel(SDL_Surface * surface, Uint16 x, Uint16 y, Uint32 color);
-
 void Affiche_hexagon (plateau_t p, int x, int y, int state);

+void Menu_button (plateau_t p, bool pointe);
+
 plateau_t init_plateau (SDL_Surface* window);

 plateau_t load_plateau (SDL_Surface* window, int* hist);
--- a/src/en_jeu.c
+++ b/src/en_jeu.c
@@ -7,6 +7,8 @@

 #include "en_jeu.h"

+#include <stdlib.h>
+
 #include "globals.h"
 #include "action_plateau.h"
 #include "affichage_plateau.h"
@@ -14,9 +16,31 @@
 #include "param.h"
 #include "sauvegarde.h"
 #include "scrolling.h"
+#include "menu_en_jeu.h"
+
+bool fake_IA (plateau_t p, bool* end)
+{
+	if (!*end)
+	{
+		int casejouee;
+		do
+		{
+			casejouee = rand() % (NBSIDE * NBSIDE);
+		} while (p->grid [casejouee] != 0);
+		p->grid [casejouee] = PLAYER(p->player);
+		p->hist [p->nb_coups++] = casejouee;
+		p->player = !p->player;
+		Affiche_hexagon (p, casejouee / NBSIDE, casejouee % NBSIDE, NORMAL);
+		//Affiche_hexagon (p, p->hist[p->nb_coups - 2] / NBSIDE, p->hist[p->nb_coups - 2] % NBSIDE, PLAYER(p->player));
+		*end = testGagne (p->grid, PLAYER(!p->player));
+		return true;
+	}
+	return false;
+}

 void en_jeu (SDL_Surface* window, int* hist)
 {
+	Reset_window(window);
 	Mix_PlayMusic(param->music, -1);
 	plateau_t plateau;
 	if (hist == NULL)
@@ -25,16 +49,18 @@ void en_jeu (SDL_Surface* window, int* hist)
 		plateau = load_plateau (window, hist);
 	vec2 c = {0, 0};
 	bool end = false;
-	scrolling_t s = init_dynamic_scroll (window, plateau);
+	bool gagne = false;
+	d_scrolling_t d = init_dynamic_scroll (window, plateau);
+	bool button = false;
 	while (!end)
 	{
-		SDL_Event event = dynamic_scroll (window, s, plateau);
-		//SDL_WaitEvent (&event);
+		SDL_Event event = dynamic_scroll (window, d, plateau);
 		switch (event.type)
 		{
 			case SDL_VIDEORESIZE:
 				resize_window(window, &event);
 				plateau = actu_plateau(plateau);
+				d = resize_dynamic_scroll (window, d, plateau);
 				break;
 			case SDL_KEYDOWN:
 				if (event.key.keysym.sym == SDLK_ESCAPE)
@@ -45,34 +71,82 @@ void en_jeu (SDL_Surface* window, int* hist)
 					plateau = actu_plateau(plateau);
 				}
 				else if (event.key.keysym.sym == SDLK_RETURN)
-					end = selection (plateau, c);
+					if (button)
+					{
+						if (menu_en_jeu(plateau) == M_DOWN)
+							end = true;
+					}
+					else
+						gagne = selection (plateau, c);
 				else if (SDLK_UP <= event.key.keysym.sym && event.key.keysym.sym <= SDLK_LEFT)
-					deplacement(plateau, &event, &c);
+					deplacement_key(plateau, event.key.keysym.sym, &c);
 				else if (event.key.keysym.sym == SDLK_a || event.key.keysym.sym == SDLK_b || event.key.keysym.sym == SDLK_n)
 					east1 (window, event.key.keysym.sym);
-				else if (event.key.keysym.sym == SDLK_s)
+				else if (event.key.keysym.sym == SDLK_m)
 				{
-					sauvegarde ("1", plateau->hist, 0);
+					char* entries [5] = {"Joueur-IA1", "2 Joueurs", "Type", "Joueur-IA2", "IA1-IA2"};
+					menu_t type = init_menu (window, entries);
+					Affiche_menu (type);
 				}
 				break;
 			case SDL_MOUSEBUTTONUP:
-				end = selection (plateau, c);
+				if (button)
+				{
+					if (menu_en_jeu(plateau) == M_DOWN)
+						end = true;
+				}
+				else
+					gagne = selection (plateau, c);
 				break;
 			case SDL_MOUSEMOTION:
-				deplacement(plateau, &event, &c);
+			{
+				bool tmp = d_menu_mouse(plateau, event.motion);
+				if (button && !tmp)
+					Menu_button (plateau, 0);
+					button = tmp;
+				if (!button)
+					deplacement_mouse(plateau, event.motion, &c);
 				break;
+			}
 			case SDL_QUIT:
 				end = true;
 				break;
+			default:
+			{
+				Uint8 *keyboard = SDL_GetKeyState(NULL);
+				if (keyboard [SDLK_UP])
+					deplacement_key (plateau, SDLK_UP, &c);
+				if (keyboard [SDLK_DOWN])
+					deplacement_key (plateau, SDLK_DOWN, &c);
+				if (keyboard [SDLK_LEFT])
+					deplacement_key (plateau, SDLK_LEFT, &c);
+				if (keyboard [SDLK_RIGHT])
+					deplacement_key (plateau, SDLK_RIGHT, &c);
 			}
+			
 		}
+		if (gagne)
+		{
 			while (!end)
 			{
-		SDL_Event event;
-		SDL_WaitEvent (&event);
-		if (event.type == SDL_QUIT)
+				char new [50];
+				sprintf (new, "Joueur %d Gagne !!", PLAYER(!plateau->player));
+				SDL_Surface* txt;
+				if (PLAYER(!plateau->player) == J1)
+					txt = TTF_RenderUTF8_Blended (param->font, new, param->rgb_j1);
+				else
+					txt = TTF_RenderUTF8_Blended (param->font, new, param->rgb_j2);
+				SDL_Surface* final = rotozoomSurface (txt, .0, window->w / txt->w, 1);
+				SDL_FreeSurface (txt);
+				SDL_BlitSurface (final, NULL , window, NULL);
+				SDL_FreeSurface (final);
+				SDL_Event e;
+				SDL_WaitEvent (&e);
+				if (e.type == SDL_QUIT || (e.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_ESCAPE))
 					end = true;
 			}
+		}
+	}
 	free_plateau (plateau);
 	Mix_HaltMusic();
 	Mix_RewindMusic();
--- a/src/globals.h
+++ b/src/globals.h
@@ -6,10 +6,13 @@
 #include <SDL/SDL_mixer.h>
 #include <stdbool.h>

+#define OK 0
+
 #define DWIDTH 800
 #define DHEIGHT 600

 #define NBSIDE param->size
+#define MAXSIZE 20

 #define PI 3.14159265
 #define RAC3 1.73205080757
@@ -20,11 +23,12 @@
 #define NORMAL 0
 #define POINTE 1

-#define M_JOUER 0
-#define M_CHARGER 1
-#define M_OPTIONS 2
-#define M_QUITTER 3
-#define M_HEX 5
+#define M_UP 0
+#define M_LEFT 1
+#define M_RIGHT 2
+#define M_DOWN 3
+#define M_MID 5
+#define M_NOT 6

 typedef struct s_vec3{
 	int x;
@@ -40,6 +44,8 @@ typedef struct s_vec2{
 typedef struct s_vec2 curseur_t;

 typedef struct s_menu {
+	char** entries;
+	int nb_entries;
 	int l;
 	int r;
 	vec2 pos;
@@ -58,6 +64,8 @@ typedef struct s_plateau {
 	int *hist;
 	int nb_coups;
 	bool player;
+	int ia;
+	SDL_Rect menu;
 }* plateau_t;

 typedef struct s_param {
--- a/src/hex.c
+++ b/src/hex.c
@@ -4,6 +4,8 @@
 ********************************************************/

 #include <SDL/SDL.h>
+#include <stdlib.h>
+#include <time.h>
 #include "window.h"
 #include "globals.h"
 #include "menu_principal.h"
@@ -13,30 +15,33 @@

 int main(int argc, char **argv)
 {
+	srand(time(0));
 	SDL_Surface* window = init_window();
 	load_param(window);
 	Reset_window (window);
 	bool end = 0;
+	char* file;
 	while (!end)
 	{
-		int retour = menu_principal(window);
-		Reset_window(window);
-		switch (retour)
+		switch (menu_principal(window, &file))
 		{
-		case M_JOUER:
+		case M_UP:
 			en_jeu (window, NULL);
 			Reset_window(window);
 			break;
-		case M_CHARGER:
+		case M_LEFT:
 		{
 			int * hist;
 			int ia;
-			printf (" -- %d\n", chargement ("1", &hist, &ia));
+			int err = chargement (file, &hist, &ia);
+			if (err != OK)
+				printf ("Erreur chargement : %d\n", err);
+			else
 				en_jeu (window, hist);
 				Reset_window(window);
 			break;
 		}
-		case M_QUITTER:
+		case M_DOWN:
 			end = 1;
 		}
 	}
--- a/src/menu.c
+++ b/src/menu.c
@@ -0,0 +1,80 @@
+/*
+ * menu.c
+ *
+ *  Created on: 9 mai 2016
+ *      Author: nathan
+ */
+
+#include "menu.h"
+
+#include "action_menu.h"
+#include "affichage_menu.h"
+#include "window.h"
+
+
+
+menu_t init_menu (SDL_Surface* window, char** entries)
+{
+	menu_t m = malloc (sizeof (struct s_menu));
+	m->entries = entries;
+	m->window = window;
+	m->cur.x = 1;
+	m->cur.y = 1;
+	m->c = 0;
+	return m;
+}
+
+void free_menu (menu_t m)
+{
+	free (m);
+}
+
+int evenement_menu (SDL_Surface* window, menu_t m, SDL_Event event, bool persist_select)
+{
+	switch (event.type)
+	{
+		case SDL_VIDEORESIZE:
+			resize_window(window, &event);
+			Affiche_menu (m);
+			break;
+		case SDL_KEYDOWN:
+			if (event.key.keysym.sym == SDLK_f)
+			{
+				window = fullscreen_window(window);
+				Affiche_menu (m);
+			}
+			else if (event.key.keysym.sym == SDLK_RETURN)
+				return selection_menu (m);
+			else if (SDLK_UP <= event.key.keysym.sym && event.key.keysym.sym <= SDLK_LEFT)
+				deplacement_menu_key (m, event.key.keysym.sym);
+			else
+				east1 (window, event.key.keysym.sym);
+			break;
+		case SDL_MOUSEBUTTONUP:
+			return selection_menu (m);
+			break;
+		case SDL_MOUSEMOTION:
+			deplacement_menu_mouse (m, &event);
+			break;
+		default:
+		{
+			Uint8 *keyboard = SDL_GetKeyState(NULL);
+			if (keyboard [SDLK_UP])
+				deplacement_menu_key (m, SDLK_UP);
+			if (keyboard [SDLK_DOWN])
+				deplacement_menu_key (m, SDLK_DOWN);
+			if (keyboard [SDLK_LEFT])
+				deplacement_menu_key (m, SDLK_LEFT);
+			if (keyboard [SDLK_RIGHT])
+				deplacement_menu_key (m, SDLK_RIGHT);
+			if (persist_select)
+			{
+				if (keyboard [SDLK_RETURN])
+					return selection_menu (m);
+				if (SDL_GetMouseState(NULL, NULL) & SDL_BUTTON(SDL_BUTTON_LEFT))
+					return selection_menu (m);
+			}
+		}
+	}
+	return M_NOT;
+}
--- a/src/menu.h
+++ b/src/menu.h
@@ -0,0 +1,22 @@
+/*
+ * menu.h
+ *
+ *  Created on: 9 mai 2016
+ *      Author: nathan
+ */
+
+#ifndef _SRC_MENU_H_
+#define _SRC_MENU_H_
+
+#include <stdbool.h>
+#include <SDL/SDL.h>
+
+#include "globals.h"
+
+menu_t init_menu (SDL_Surface* window, char** entries);
+
+void free_menu (menu_t m);
+
+int evenement_menu (SDL_Surface* window, menu_t m, SDL_Event event, bool persist_select);
+
+#endif /* _SRC_MENU_H_ */
--- a/src/menu_en_jeu.c
+++ b/src/menu_en_jeu.c
@@ -0,0 +1,227 @@
+/*
+ * menu_en_jeu.c
+ *
+ *  Created on: 9 mai 2016
+ *      Author: nathan
+ */
+
+#include "menu_en_jeu.h"
+
+#include "affichage_menu.h"
+#include "affichage_plateau.h"
+#include "menu.h"
+#include "sub_menu.h"
+#include "sauvegarde.h"
+
+
+void random_char_9 (char* s)
+{
+	for (int i = 0; i < 8; ++i)
+		s[i] = 'A' + rand() % 26;
+	s[9]= '\0';
+}
+
+bool d_menu_mouse (plateau_t p, SDL_MouseMotionEvent motion)
+{
+	if (p->menu.x < motion.x && motion.x < p->menu.x + p->menu.w && p->menu.y < motion.y && motion.y < p->menu.y + p->menu.h)
+	{
+		Menu_button (p, 1);
+		return true;
+	}
+	return false;
+}
+
+int menu_save (plateau_t p)
+{
+	char* entries [5] = {"<", "Save", "", "Retour", ">"};
+	entries [2] = malloc (sizeof (char) * 12);
+	int cur = 0;
+	strcpy (entries [2], "_\0");
+	menu_t m = init_menu (p->window, entries);
+	Affiche_menu(m);
+	int retour;
+	bool end = false;
+
+	while (!end)
+	{
+		SDL_Event event;
+		SDL_WaitEvent (&event);
+		if (event.type == SDL_QUIT || (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_ESCAPE))
+		{
+			retour = M_DOWN;
+		}
+		else if (event.type == SDL_KEYDOWN && SDLK_a <= event.key.keysym.sym && event.key.keysym.sym <= SDLK_z && cur < 8)
+		{
+			Uint8* keyboard = SDL_GetKeyState(NULL);
+			if ((keyboard [SDLK_RSHIFT] || keyboard [SDLK_LSHIFT]) ^ keyboard [SDLK_CAPSLOCK])
+				entries [2] [cur] = event.key.keysym.sym - 'a' + 'A';
+			else
+				entries [2] [cur] = event.key.keysym.sym;
+			++cur;
+			if (cur == 8)
+				entries [2] [cur] = '\0';
+			else
+			{
+				entries [2] [cur] = '_';
+				entries [2] [cur + 1] = '\0';
+			}
+			vec2 c = m->cur;
+			m->cur.x = 1;
+			m->cur.x = 1;
+			Affiche_entry (m, 0);
+			m->cur = c;
+		}
+		else if (event.type == SDL_KEYDOWN && SDLK_KP0 <= event.key.keysym.sym && event.key.keysym.sym <= SDLK_KP9 && cur < 8)
+		{
+			entries [2] [cur] = event.key.keysym.sym - SDLK_KP0 + '0';
+			++cur;
+			if (cur == 8)
+				entries [2] [cur] = '\0';
+			else
+			{
+				entries [2] [cur] = '_';
+				entries [2] [cur + 1] = '\0';
+			}
+			vec2 c = m->cur;
+			m->cur.x = 1;
+			m->cur.x = 1;
+			Affiche_entry (m, 0);
+			m->cur = c;
+		}
+		else if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_BACKSPACE && cur > 0)
+		{
+			entries [2] [cur] = '\0';
+			--cur;
+			entries [2] [cur] = '_';
+			vec2 c = m->cur;
+			m->cur.x = 1;
+			m->cur.x = 1;
+			Affiche_entry (m, 0);
+			m->cur = c;
+		}
+		else
+			retour = evenement_menu(p->window, m, event, 0);
+
+		switch (retour)
+		{
+		case M_UP:
+			if (0 < cur && strlen (entries [2]) < 9)
+			{
+				end = true;
+				char** liste;
+				int nb = listeSauvegarde (&liste);
+				for (int i = 0; i < nb && end; ++i)
+					if (!strcmp (entries [2], liste [i]))
+					{
+						strcpy (entries [2], "existe déjà");
+						cur = 1;
+						vec2 c = m->cur;
+						m->cur.x = 1;
+						m->cur.x = 1;
+						Affiche_entry (m, 0);
+						m->cur = c;
+						end = 0;
+					}
+				free_liste (liste, nb);
+				if (end)
+				{
+					entries [2] [cur] = '\0';
+					sauvegarde (entries [2], p->hist, p->ia);
+				}
+			}
+			break;
+		case M_LEFT :
+		{
+			random_char_9 (entries [2]);
+			cur = 8;
+			vec2 c = m->cur;
+			m->cur.x = 1;
+			m->cur.x = 1;
+			Affiche_entry (m, 0);
+			m->cur = c;
+			break;
+		}
+		case M_RIGHT :
+		{
+			random_char_9 (entries [2]);
+			cur = 8;
+			vec2 c = m->cur;
+			m->cur.x = 1;
+			m->cur.x = 1;
+			Affiche_entry (m, 0);
+			m->cur = c;
+			break;
+		}
+		case M_DOWN :
+			end = true;
+			break;
+		case M_MID :
+			break;
+		}
+	}
+
+
+	free_menu(m);
+	free (entries [2]);
+	return retour;
+}
+
+int menu_en_jeu (plateau_t p)
+{
+	SDL_Surface* save = SDL_CreateRGBSurface (SDL_HWSURFACE, p->window->w, p->window->h, p->window->format->BitsPerPixel, 0, 0, 0, 0);
+	SDL_BlitSurface (p->window, NULL, save, NULL);
+	SDL_Surface* ombre = SDL_CreateRGBSurface (SDL_HWSURFACE, p->window->w, p->window->h, p->window->format->BitsPerPixel, 0, 0, 0, 0);
+	SDL_FillRect (ombre, NULL, SDL_MapRGB (p->window->format, 0, 0, 0));
+	SDL_SetAlpha(ombre, SDL_SRCALPHA, 200);
+	SDL_BlitSurface (ombre, NULL, p->window, NULL);
+	SDL_FreeSurface (ombre);
+
+	char* entries [5] = {"Music", "Save", "HEX", "Quitter", " Son "};
+	menu_t m = init_menu (p->window, entries);
+	Affiche_menu(m);
+	int retour;
+	bool end = false;
+
+	while (!end)
+	{
+		SDL_Event event;
+		SDL_WaitEvent (&event);
+		if (event.type == SDL_QUIT || (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_ESCAPE))
+		{
+			retour = M_DOWN;
+		}
+		else
+			retour = evenement_menu(p->window, m, event, 0);
+		switch (retour)
+		{
+		case M_UP:
+			menu_save (p);
+			m->cur.x = 1;
+			m->cur.y = 1;
+			Affiche_menu(m);
+			break;
+		case M_LEFT :
+			menu_music (p->window, NULL);
+			m->cur.x = 1;
+			m->cur.y = 1;
+			Affiche_menu(m);
+			break;
+		case M_RIGHT :
+			menu_son (p->window, NULL);
+			m->cur.x = 1;
+			m->cur.y = 1;
+			Affiche_menu(m);
+			break;
+		case M_DOWN :
+			end = true;
+			break;
+		case M_MID :
+			end = true;
+			break;
+		}
+	}
+	free_menu(m);
+	SDL_BlitSurface (save, NULL, p->window, NULL);
+	SDL_FreeSurface (save);
+	return retour;
+}
--- a/src/menu_en_jeu.h
+++ b/src/menu_en_jeu.h
@@ -0,0 +1,20 @@
+/*
+ * menu_en_jeu.h
+ *
+ *  Created on: 9 mai 2016
+ *      Author: nathan
+ */
+
+#ifndef _MENU_EN_JEU_H_
+#define _MENU_EN_JEU_H_
+
+#include <stdbool.h>
+#include <SDL/SDL.h>
+
+#include "globals.h"
+
+bool d_menu_mouse (plateau_t p, SDL_MouseMotionEvent motion);
+
+int menu_en_jeu (plateau_t p);
+
+#endif /* _MENU_EN_JEU_H_ */
--- a/src/menu_principal.c
+++ b/src/menu_principal.c
@@ -1,160 +1,255 @@
 #include "menu_principal.h"

-#include "action_menu_principal.h"
-#include "affichage_menu_principal.h"
+#include <math.h>
+
+#include "action_menu.h"
+#include "affichage_menu.h"
+#include "menu.h"
 #include "globals.h"
 #include "window.h"
 #include "scrolling.h"
+#include "sound.h"
+#include "sauvegarde.h"
+#include "sub_menu.h"

-menu_t init_menu_principal (SDL_Surface* window)
+int menu_taille (SDL_Surface* window, scrolling_t scroll)
 {
-	menu_t m = malloc (sizeof (struct s_menu));
-	m->window = window;
-	m->cur.x = 1;
-	m->cur.y = 1;
-	m->c = 0;
-	return m;
-}
-
-menu_t init_menu_options (SDL_Surface* window)
-{
-	menu_t m = malloc (sizeof (struct s_menu));
-	m->window = window;
-	m->cur.x = 1;
-	m->cur.y = 1;
-	return m;
-}
-
-void free_menu (menu_t m)
-{
-	free (m);
-}
-
-scrolling_t resize_scroll (SDL_Surface* w, scrolling_t s)
-{
-	char** msg = s->msgstr;
-	SDL_Color* c = s->c;
-	int nb = s->nb_surf;
-	free_scroll (s);
-	s = init_scroll (w, msg, c, nb);
-	return s;
-}
-
-int menu_options (SDL_Surface* window, scrolling_t s, menu_t m)
-{
-	Affiche_menu_options (window, m->r, m->l);
-	bool end = 0;
-	if (end)
-		end = 1;
-	/*while (!end)
-	{
-		SDL_Event event;
-		event = scroll_msg (window, s);
-		switch (event.type)
-		{
-			case SDL_VIDEORESIZE:
-				resize_window(window, &event);
-				Affiche_menu_principal(m);
-				s = resize_scroll(window, s);
-				break;
-			case SDL_KEYDOWN:
-				if (event.key.keysym.sym == SDLK_ESCAPE)
-					end = 1;
-				break;
-				else if (event.key.keysym.sym == SDLK_f)
-				{
-					window = fullscreen_window(window);
-					Affiche_menu_principal(m);
-					scroll = resize_scroll(window, scroll);
-				}
-				else if (event.key.keysym.sym == SDLK_RETURN)
-					end = selection_menu (m, &retour);
-				else if (SDLK_UP <= event.key.keysym.sym && event.key.keysym.sym <= SDLK_LEFT)
-					deplacement_menu (m, &event);
-				break;
-			case SDL_MOUSEBUTTONUP:
-				end = selection_menu (m, &retour);
-				break;
-			case SDL_MOUSEMOTION:
-				deplacement_menu (m, &event);
-				break;
-			case SDL_QUIT:
-				end = 1;
-				break;
-		}
-	}*/
-	return 0;
-}
-
-int menu_principal (SDL_Surface* window)
-{
-	menu_t m = init_menu_principal (window);
-	Affiche_menu_principal(m);
+	char* entries [5] = {"<", "TAILLE", "", "Retour", ">"};
+	entries [2] = malloc (sizeof (char)* 8);
+	sprintf (entries [2], "%dx%d", param->size, param->size);
+	menu_t m = init_menu (window, entries);
+	Affiche_menu(m);
 	int retour;
-	bool end = 0;
-	char* message [] = {"Crédits : petite bite & gros chakal Corp.", "Breaking News : Le Soudan en manque de soudeurs", "lmqsdkmq", "There is nothing to see here ... BASTARD !"};
-	SDL_Color c [] = {{170,10,107}, {60,255,1}, {0, 0, 0}, {200, 180, 201}};
-	scrolling_t scroll = init_scroll (window, message, c, 4);
+	bool end = false;
+
 	while (!end)
 	{
 		SDL_Event event;
 		event = scroll_msg (window, scroll);
-		switch (event.type)
+		if (event.type == SDL_QUIT || (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_ESCAPE))
 		{
-			case SDL_VIDEORESIZE:
-				resize_window(window, &event);
-				Affiche_menu_principal(m);
-				scroll = resize_scroll(window, scroll);
-				break;
-			case SDL_KEYDOWN:
-				if (event.key.keysym.sym == SDLK_ESCAPE)
-				{
-					retour = M_QUITTER;
-					end = 1;
+			retour = M_DOWN;
 		}
-				else if (event.key.keysym.sym == SDLK_f)
-				{
-					window = fullscreen_window(window);
-					Affiche_menu_principal(m);
-					scroll = resize_scroll(window, scroll);
-				}
-				else if (event.key.keysym.sym == SDLK_RETURN)
-					end = selection_menu (m, &retour);
-				else if (SDLK_UP <= event.key.keysym.sym && event.key.keysym.sym <= SDLK_LEFT)
-					deplacement_menu_key (m, event.key.keysym.sym);
 		else
-					east1 (window, event.key.keysym.sym);
-				break;
-			case SDL_MOUSEBUTTONUP:
-				end = selection_menu (m, &retour);
-				break;
-			case SDL_MOUSEMOTION:
-				deplacement_menu_mouse (m, &event);
-				break;
-			case SDL_QUIT:
-				retour = M_QUITTER;
-				end = 1;
-				break;
-			default:
+			retour = evenement_menu(window, m, event, 0);
+		if (event.type == SDL_VIDEORESIZE || (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_f))
+			scroll = resize_scroll(window, scroll);
+		switch (retour)
 		{
-				Uint8 *keyboard = SDL_GetKeyState(NULL);
-				if (keyboard [SDLK_UP])
-					deplacement_menu_key (m, SDLK_UP);
-				if (keyboard [SDLK_DOWN])
-					deplacement_menu_key (m, SDLK_DOWN);
-				if (keyboard [SDLK_LEFT])
-					deplacement_menu_key (m, SDLK_LEFT);
-				if (keyboard [SDLK_RIGHT])
-					deplacement_menu_key (m, SDLK_RIGHT);
+		case M_UP:
+			break;
+		case M_LEFT :
+			if (param->size > 1)
+			{
+				--param->size;
+				sprintf (entries [2], "%dx%d", param->size, param->size);
+				vec2 c = m->cur;
+				m->cur.x = 1;
+				m->cur.x = 1;
+				Affiche_entry (m, 0);
+				m->cur = c;
+			}
+			break;
+		case M_RIGHT :
+		{
+			if (param->size < SIZE_MAX)
+			{
+				++param->size;
+				sprintf (entries [2], "%dx%d", param->size, param->size);
+				vec2 c = m->cur;
+				m->cur.x = 1;
+				m->cur.x = 1;
+				Affiche_entry (m, 0);
+				m->cur = c;
+			}
+			break;
+		}
+		case M_DOWN :
+			end = true;
+			break;
+		case M_MID :
+			break;
+		}
+	}
+	free (entries [2]);
+	free_menu(m);
+	Mix_HaltMusic();
+	return retour;
 }

-		}
-		if (retour == M_OPTIONS)
+int menu_options (SDL_Surface* window, scrolling_t scroll)
 {
-			menu_options (window, scroll, m);
-			retour = -1;
+	char* entries [5] = {"Music", "Taille", "OPTIONS", "Retour", " Son "};
+	menu_t m = init_menu (window, entries);
+	Affiche_menu(m);
+	int retour;
+	bool end = false;
+
+	while (!end)
+	{
+		SDL_Event event;
+		event = scroll_msg (window, scroll);
+		if (event.type == SDL_QUIT || (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_ESCAPE))
+		{
+			retour = M_DOWN;
+		}
+		else
+			retour = evenement_menu(window, m, event, 0);
+		if (event.type == SDL_VIDEORESIZE || (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_f))
+			scroll = resize_scroll(window, scroll);
+		switch (retour)
+		{
+		case M_UP:
+			menu_taille (window, scroll);
+			m->cur.x = 1;
+			m->cur.y = 1;
+			Affiche_menu(m);
+			break;
+		case M_LEFT :
+			menu_music (window, scroll);
+			m->cur.x = 1;
+			m->cur.y = 1;
+			Affiche_menu(m);
+			break;
+		case M_RIGHT :
+			menu_son (window, scroll);
+			m->cur.x = 1;
+			m->cur.y = 1;
+			Affiche_menu(m);
+			break;
+		case M_DOWN :
+			end = true;
+			break;
+		case M_MID :
+			break;
+		}
+	}
+	free_menu(m);
+	return retour;
 }

+int menu_charger (SDL_Surface* window, scrolling_t scroll, char** file)
+{
+	char* entries [5] = {"<", "CHARGER", "", "Retour", ">"};
+	entries [2] = malloc (sizeof (char)* 9);
+	char** liste;
+	int nb_sav = listeSauvegarde(&liste);
+	int cur = 0;
+	sprintf (entries [2], "%s", liste[cur]);
+	menu_t m = init_menu (window, entries);
+	Affiche_menu(m);
+	int retour;
+	bool end = false;
+
+	while (!end)
+	{
+		SDL_Event event;
+		event = scroll_msg (window, scroll);
+		if (event.type == SDL_QUIT || (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_ESCAPE))
+		{
+			retour = M_DOWN;
+		}
+		else
+			retour = evenement_menu(window, m, event, 0);
+		if (event.type == SDL_VIDEORESIZE || (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_f))
+			scroll = resize_scroll(window, scroll);
+		switch (retour)
+		{
+		case M_UP:
+			*file = malloc (sizeof (char) * (strlen(entries[2]) + 1));
+			strcpy (*file, entries [2]);
+			end = true;
+			retour = M_UP;
+			break;
+		case M_LEFT :
+		{
+
+			if (!cur)
+				cur = nb_sav - 1;
+			else
+				--cur;
+			sprintf (entries [2], "%s", liste[cur]);
+			vec2 c = m->cur;
+			m->cur.x = 1;
+			m->cur.x = 1;
+			Affiche_entry (m, 0);
+			m->cur = c;
+			break;
+		}
+		case M_RIGHT :
+		{
+			cur = (cur + 1) % nb_sav;
+			sprintf (entries [2], "%s", liste[cur]);
+			vec2 c = m->cur;
+			m->cur.x = 1;
+			m->cur.x = 1;
+			Affiche_entry (m, 0);
+			m->cur = c;
+			break;
+		}
+		case M_DOWN :
+			end = true;
+			break;
+		case M_MID :
+			break;
+		}
+	}
+	free (entries [2]);
+	free_liste (liste, nb_sav);
+	free_menu(m);
+	return retour;
+}
+
+int menu_principal (SDL_Surface* window, char** file)
+{
+	char* entries [5] = {"Charger", "Jouer", "HEX", "Quitter", "Options"};
+	menu_t m = init_menu (window, entries);
+	Affiche_menu(m);
+	int retour;
+	bool end = false;
+	char* message [] = {"Crédits : petite bite & gros chakal Corp.", "Breaking News : Le Soudan en manque de soudeurs", "lmqsdkmq", "There is nothing to see here ... BASTARD !"};
+	SDL_Color c [] = {{170,10,107}, {60,255,1}, {0, 0, 0}, {200, 180, 201}};
+	scrolling_t scroll = init_scroll (window, message, c, 4);
+
+	while (!end)
+	{
+		SDL_Event event;
+		event = scroll_msg (window, scroll);
+		if (event.type == SDL_QUIT || (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_ESCAPE))
+		{
+			retour = M_DOWN;
+		}
+		else
+			retour = evenement_menu(window, m, event, 0);
+		switch (retour)
+		{
+		case M_UP:
+			end = true;
+			break;
+		case M_LEFT :
+			if (menu_charger (window, scroll, file) == M_UP)
+			{
+				end = true;
+				retour = M_LEFT;
+			}
+			m->cur.x = 1;
+			m->cur.y = 1;
+			Affiche_menu(m);
+			break;
+		case M_RIGHT :
+			menu_options (window, scroll);
+			m->cur.x = 1;
+			m->cur.y = 1;
+			Affiche_menu(m);
+			break;
+		case M_DOWN :
+			end = true;
+			break;
+		case M_MID :
+			break;
+		}
+		if (event.type == SDL_VIDEORESIZE || (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_f))
+			scroll = resize_scroll(window, scroll);
 	}
 	free_menu(m);
 	free_scroll (scroll);
--- a/src/menu_principal.h
+++ b/src/menu_principal.h
@@ -3,6 +3,6 @@

 #include <SDL/SDL.h>

-int menu_principal (SDL_Surface* window);
+int menu_principal (SDL_Surface* window, char** file);

 #endif /* _MENU_PRINCIPAL_H_ */
--- a/src/sauvegarde.c
+++ b/src/sauvegarde.c
@@ -21,7 +21,7 @@ int listeSauvegarde(char*** nomSave){
 	while((d=readdir(rep))!=NULL)
 	{
 		ext=strlen(d->d_name);
-		if (ext>3 && !strcmp(&d->d_name[ext-4], ".sav")){
+		if (ext>3 && !strcmp(&d->d_name[ext-4], ".sav") && ext<13){
 			nbSave++;
 		}
 	}
@@ -32,13 +32,13 @@ int listeSauvegarde(char*** nomSave){
 	while((d=readdir(rep))!=NULL)
 	{
 		ext=strlen(d->d_name);
-		if (ext>3 && !strcmp(&d->d_name[ext-4], ".sav")){
+		if (ext>3 && !strcmp(&d->d_name[ext-4], ".sav") && ext<13){
 			tmp[i]=malloc(sizeof(char)*(ext-2));
 			for(j=0;j<ext-4;j++){
 				tmp[i][j]= d->d_name[j];
 			}
 			
-			tmp[i][ext-3]=0;
+			tmp[i][ext-4]=0;
 			i++;
 		}
 	}
@@ -48,6 +48,13 @@ int listeSauvegarde(char*** nomSave){
 	
 }

+void free_liste (char** liste, int n)
+{
+	for (int i = 0; i < n; ++i)
+		free (liste[i]);
+	free (liste);
+}
+
 // Renvoi 0 si la sauvegarde a eu lieu et 1 si il y a eu problème

 int sauvegarde (char * nom, int * tab, int IA)
@@ -96,7 +103,7 @@ int chargement(char *nom , int **tab, int *IA)
 		return ERROR_IA;
 	}
 	fscanf(f_chargement, "%d", &taille);
-	if(taille<1 || taille > 25){
+	if(taille<1 || taille > SIZE_MAX){
 		return ERROR_SIZE;
 	}

--- a/src/sauvegarde.h
+++ b/src/sauvegarde.h
@@ -1,3 +1,6 @@
+#ifndef _SAVEGARDE_H_
+#define _SAVEGARDE_H_
+
 #define ERROR_IA 1
 #define ERROR_SIZE 2
 #define ERROR_NB_VALUE 3
@@ -5,5 +8,8 @@
 #define ERROR_CREATE_DIR 11

 int listeSauvegarde(char*** nomSave );
+void free_liste (char** liste, int n);
 int sauvegarde (char * nom , int * tab, int IA);
 int chargement (char *nom , int **tab, int *IA);
+
+#endif /* _SAVEGARDE_H_ */
--- a/src/scrolling.c
+++ b/src/scrolling.c
@@ -130,6 +130,16 @@ void free_scroll (scrolling_t s)
 	free (s);
 }

+scrolling_t resize_scroll (SDL_Surface* w, scrolling_t s)
+{
+	char** msg = s->msgstr;
+	SDL_Color* c = s->c;
+	int nb = s->nb_surf;
+	free_scroll (s);
+	s = init_scroll (w, msg, c, nb);
+	return s;
+}
+
 SDL_Event scroll_msg (SDL_Surface* window, scrolling_t s)
 {
 	int t0 = SDL_GetTicks();
@@ -237,3 +247,45 @@ SDL_Event dynamic_scroll (SDL_Surface* window, d_scrolling_t d, plateau_t p)

 	return e;
 }
+
+d_scrolling_t resize_dynamic_scroll (SDL_Surface* window, d_scrolling_t d, plateau_t p)
+{
+	free_scroll (d->s);
+	d->s = malloc (sizeof (struct s_scrolling));
+	char* msg [2] = {"Au tour du Joueur 2", "Au tour du Joueur 1"};
+	SDL_Color c [2] = {param->rgb_j2, param->rgb_j1};
+
+	int size = Cadre_scroll (window);
+	d->s->nb_surf = 2;
+	d->s->c = c;
+	d->s->msgstr = msg;
+	create_messages_surfaces (d->s, size, window->format->BitsPerPixel);
+
+	d->id = p->nb_coups%2;
+	d->precedent = NULL;
+
+	nb_msg_max (d->s, window);
+
+	SDL_Surface* j1 = d->s->msg [1];
+
+	char new [50];
+	sprintf (new,  "Dernier coup : joueur %d en %2d - %2d  ", PLAYER(!p->player), p->hist[p->nb_coups - 1] / NBSIDE + 1, p->hist[p->nb_coups - 1] % NBSIDE + 1);
+	if (PLAYER(!p->player) == J1)
+		d->s->msg[1] = create_one_surface (new, param->rgb_j1, d->s->msg[0]->h, window->format->BitsPerPixel);
+	else
+		d->s->msg[1] = create_one_surface (new, param->rgb_j2, d->s->msg[0]->h, window->format->BitsPerPixel);
+
+
+	init_pos_dim (d->s, window);
+
+	d->s->first_msg = 0;
+	d->s->nb_msg = 1;
+	if (d->precedent != NULL && d->precedent != d->s->msg [1])
+				SDL_FreeSurface (d->precedent);
+	d->precedent = d->s->msg [1];
+	d->s->msg [1] = j1;
+	d->s->nb_surf = 2;
+
+	return d;
+
+}
--- a/src/scrolling.h
+++ b/src/scrolling.h
@@ -33,10 +33,14 @@ scrolling_t init_scroll (SDL_Surface* window, char** msg, SDL_Color* c, int nb_m

 void free_scroll (scrolling_t s);

+scrolling_t resize_scroll (SDL_Surface* w, scrolling_t s);
+
 SDL_Event scroll_msg (SDL_Surface* window, scrolling_t s);

 d_scrolling_t init_dynamic_scroll (SDL_Surface* window, plateau_t p);

 SDL_Event dynamic_scroll (SDL_Surface* window, d_scrolling_t d, plateau_t p);

+d_scrolling_t resize_dynamic_scroll (SDL_Surface* window, d_scrolling_t d, plateau_t p);
+
 #endif /* _SCROLLING_H_ */
--- a/src/sound.c
+++ b/src/sound.c
@@ -13,12 +13,11 @@ void Load_sound (void)
 {
 	param->music_vol = .5 * MIX_MAX_VOLUME;
 	param->music = Mix_LoadMUS ("ressources/theme.mp3");
-	Mix_VolumeMusic (0);//param->music_vol);
+	Mix_VolumeMusic (param->music_vol);//param->music_vol);

-	param->chunk_vol = .25 * MIX_MAX_VOLUME;
-	printf ("%d\n", param->chunk_vol);
+	param->chunk_vol = .5 * MIX_MAX_VOLUME;
 	param->click = Mix_LoadWAV("ressources/Click.wav");
-	Mix_VolumeChunk (param->click, .5 * param->chunk_vol);
+	Mix_VolumeChunk (param->click, param->chunk_vol);

 	param->gong = Mix_LoadWAV("ressources/Gong.wav");
 	Mix_VolumeChunk (param->gong, param->chunk_vol);
@@ -33,6 +32,7 @@ void Free_sound (void)

 void play_clik (void)
 {
+	Mix_VolumeChunk (param->click, param->chunk_vol);
 	Mix_PlayChannel(0, param->click, 0);
 }

--- a/src/sub_menu.c
+++ b/src/sub_menu.c
@@ -0,0 +1,161 @@
+/*
+ * sub_menu.c
+ *
+ *  Created on: 9 mai 2016
+ *      Author: nathan
+ */
+
+#include "sub_menu.h"
+
+#include <stdbool.h>
+
+#define VOL(x) x * MIX_MAX_VOLUME / 100
+
+int menu_music (SDL_Surface* window, scrolling_t scroll)
+{
+	bool en_jeu = Mix_PlayingMusic();
+	if (!en_jeu)
+		Mix_PlayMusic (param->music, -1);
+	char* entries [5] = {"<", "MUSIC", "", "Retour", ">"};
+	entries [2] = malloc (sizeof (char)* 4);
+	unsigned int vol = param->music_vol * 100 / MIX_MAX_VOLUME;
+	sprintf (entries [2], "%u", vol);
+	menu_t m = init_menu (window, entries);
+	Affiche_menu(m);
+	int retour;
+	bool end = false;
+
+	while (!end)
+	{
+		SDL_Event event;
+		if (scroll == NULL)
+			SDL_WaitEvent (&event);
+		else
+			event = scroll_msg (window, scroll);
+		if (event.type == SDL_QUIT || (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_ESCAPE))
+		{
+			retour = M_DOWN;
+		}
+		else
+			retour = evenement_menu(window, m, event, 1);
+		if ((event.type == SDL_VIDEORESIZE || (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_f)) && scroll != NULL)
+			scroll = resize_scroll(window, scroll);
+		switch (retour)
+		{
+		case M_UP:
+			break;
+		case M_LEFT :
+			if (param->music_vol > 0)
+			{
+				--vol;
+				sprintf (entries [2], "%d", vol);
+				param->music_vol = VOL (vol);
+				Mix_VolumeMusic (param->music_vol);
+				vec2 c = m->cur;
+				m->cur.x = 1;
+				m->cur.x = 1;
+				Affiche_entry (m, 0);
+				m->cur = c;
+			}
+			break;
+		case M_RIGHT :
+		{
+			if (param->music_vol < MIX_MAX_VOLUME)
+			{
+				++vol;
+				sprintf (entries [2], "%d", vol);
+				param->music_vol = VOL (vol);
+				Mix_VolumeMusic (param->music_vol);
+				vec2 c = m->cur;
+				m->cur.x = 1;
+				m->cur.x = 1;
+				Affiche_entry (m, 0);
+				m->cur = c;
+			}
+			break;
+		}
+		case M_DOWN :
+			end = true;
+			break;
+		case M_MID :
+			break;
+		}
+	}
+	free (entries [2]);
+	free_menu(m);
+	if (!en_jeu)
+		Mix_HaltMusic();
+	return retour;
+}
+
+int menu_son (SDL_Surface* window, scrolling_t scroll)
+{
+	char* entries [5] = {"<", " SON ", "", "Retour", ">"};
+	entries [2] = malloc (sizeof (char)* 4);
+	unsigned int vol = param->chunk_vol * 100 / MIX_MAX_VOLUME;
+	sprintf (entries [2], "%u", vol);
+	menu_t m = init_menu (window, entries);
+	Affiche_menu(m);
+	int retour;
+	bool end = false;
+
+	while (!end)
+	{
+		SDL_Event event;
+		if (scroll == NULL)
+			SDL_WaitEvent (&event);
+		else
+			event = scroll_msg (window, scroll);
+		if (event.type == SDL_QUIT || (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_ESCAPE))
+		{
+			retour = M_DOWN;
+		}
+		else
+			retour = evenement_menu(window, m, event, 1);
+		if ((event.type == SDL_VIDEORESIZE || (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_f)) && scroll != NULL)
+			scroll = resize_scroll(window, scroll);
+		switch (retour)
+		{
+		case M_UP:
+			break;
+		case M_LEFT :
+			if (param->chunk_vol > 0)
+			{
+				--vol;
+				sprintf (entries [2], "%d", vol);
+				param->chunk_vol = VOL (vol);
+				play_clik();
+				vec2 c = m->cur;
+				m->cur.x = 1;
+				m->cur.x = 1;
+				Affiche_entry (m, 0);
+				m->cur = c;
+			}
+			break;
+		case M_RIGHT :
+		{
+			if (param->chunk_vol < MIX_MAX_VOLUME)
+			{
+				++vol;
+				sprintf (entries [2], "%d", vol);
+				param->chunk_vol = VOL (vol);
+				play_clik();
+				vec2 c = m->cur;
+				m->cur.x = 1;
+				m->cur.x = 1;
+				Affiche_entry (m, 0);
+				m->cur = c;
+			}
+			break;
+		}
+		case M_DOWN :
+			end = true;
+			break;
+		case M_MID :
+			break;
+		}
+	}
+	free (entries [2]);
+	free_menu(m);
+	return retour;
+}
--- a/src/sub_menu.h
+++ b/src/sub_menu.h
@@ -0,0 +1,19 @@
+/*
+ * sub_menu.h
+ *
+ *  Created on: 9 mai 2016
+ *      Author: nathan
+ */
+
+#ifndef _SUB_MENU_H_
+#define _SUB_MENU_H_
+
+#include <SDL/SDL.h>
+#include "globals.h"
+#include "scrolling.h"
+
+int menu_music (SDL_Surface* window, scrolling_t scroll);
+
+int menu_son (SDL_Surface* window, scrolling_t scroll);
+
+#endif /* _SUB_MENU_H_ */