Projets/Hex
2
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

text_scroll on menu & annoying sound

Browse Source
This commit is contained in:
Nathan 2016-04-22 12:00:29 +02:00
parent 5a28ab87e9
commit 6090b0288f
20 changed files with 690 additions and 274 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
bin/hex
View File

Binary file not shown.

7
makefile
View File

@ -1,8 +1,9 @@
CC=gcc
CFLAGS=-Wall -g -std=c99 -c -lm `sdl-config --cflags --libs` -lSDL_ttf
LDFLAGS=-std=c99 -lm `sdl-config --cflags --libs` -lSDL_ttf -lSDL_gfx
CFLAGS=-Wall -g -std=c99 -c
#-lm `sdl-config --cflags --libs` -lSDL_ttf
LDFLAGS=-std=c99 -lm `sdl-config --cflags --libs` -lSDL_ttf -lSDL_gfx -lSDL_mixer
EXEC=bin/hex
SRC=src/hex.c src/affichage_plateau.c src/action_plateau.c src/affichage_menu_principal.c src/window.c src/param.c src/en_jeu.c src/menu_principal.c src/draw.c
SRC=src/hex.c src/affichage_plateau.c src/action_plateau.c src/affichage_menu_principal.c src/window.c src/param.c src/en_jeu.c src/menu_principal.c src/draw.c src/action_menu_principal.c
#$(wildcard src/*.c)
OBJ=$(SRC:.c=.o)

BIN
ressources/Click03.wav Normal file
View File

Binary file not shown.

BIN
ressources/ico.bmp Normal file
View File

Binary file not shown.
Side by Side

After

Width:  |  Height:  |  Size: 467 KiB

153
src/action_menu_principal.c Normal file
View File

@ -0,0 +1,153 @@
/*
* action_menu_principal.c
*
* Created on: 21 avr. 2016
* Author: nathan
*/
#include "action_menu_principal.h"
#include <math.h>
#include "globals.h"
#include "affichage_menu_principal.h"
#include "param.h"
void deplacement_menu (menu_t m, SDL_Event* event)
{
char* entries [3][3] = {{"", "Charger", ""}, {"Jouer", "HEX", "Quitter"}, {"", "Options", ""}};
switch (event->type)
{
case SDL_MOUSEMOTION:
{
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, entries [m->cur.x][m->cur.y], NORMAL);
m->cur.x = hex.x;
m->cur.y = hex.y;
Affiche_entry(m, entries [hex.x][hex.y], POINTE);
Mix_PlayMusic (param->click, 1);
}
break;
}
case SDL_KEYDOWN:
while (!SDL_PollEvent(event))
{
Affiche_entry(m, entries [m->cur.x][m->cur.y], NORMAL);
switch (event->key.keysym.sym)
{
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, entries [m->cur.x][m->cur.y], POINTE);
Mix_PlayMusic (param->click, 1);
SDL_Delay (200);
}
break;
}
}
bool selection_menu (menu_t m, int* r)
{
switch (10 * m->cur.x + m->cur.y)
{
case 01:
*r = M_CHARGER;
return false;
case 10:
*r = M_JOUER;
return true;
case 11:
*r = M_HEX;
return false;
case 12:
*r = M_QUITTER;
return true;
case 21:
*r = M_OPTIONS;
return false;
default:
return false;
}
}

19
src/action_menu_principal.h Normal file
View File

@ -0,0 +1,19 @@
/*
* 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 (menu_t m, SDL_Event* event);
bool selection_menu (menu_t m, int* r);
#endif /* _ACTION_MENU_PRINCIPAL_H_ */

9
src/action_plateau.c
View File

@ -2,9 +2,11 @@
#include <math.h>
#include <SDL/SDL.h>
#include <SDL/SDL_mixer.h>
#include "affichage_plateau.h"
#include "globals.h"
#include "param.h"
void selection (plateau_t p, curseur_t c)
{
@ -86,7 +88,11 @@ void deplacement (plateau_t p, SDL_Event* event, curseur_t* c)
c->x = hex.x;
c->y = hex.y;
if (0 <= hex.x && hex.x < NBSIDE && 0 <= hex.y && hex.y < NBSIDE)
{
Affiche_hexagon(p, c->x, c->y, PLAYER(p->player));
Mix_PlayMusic (param->click, 1);
}
}
@ -124,7 +130,8 @@ void deplacement (plateau_t p, SDL_Event* event, curseur_t* c)
if (c->y < 0)
c->y = NBSIDE - 1;
Affiche_hexagon(p, c->x, c->y, PLAYER(p->player));
sleep_ms (100);
Mix_PlayMusic (param->click, 1);
SDL_Delay (100);
}
break;
}

280
src/affichage_menu_principal.c
View File

@ -3,24 +3,11 @@
#include <SDL/SDL.h>
#include <SDL/SDL_ttf.h>
#include <SDL/SDL_rotozoom.h>
#include <assert.h>
#include "param.h"
#include "draw.h"
void rectangle (SDL_Surface* window, SDL_Rect* pos)
{
SDL_Surface* rect = SDL_CreateRGBSurface (SDL_HWSURFACE, pos->w, pos->h, 32, 0, 0, 0, 0);
SDL_FillRect (rect, NULL, param->ex);
SDL_BlitSurface (rect, NULL, window, pos);
SDL_FreeSurface (rect);
rect = SDL_CreateRGBSurface (SDL_HWSURFACE, pos->w - 6, pos->h - 6, 32, 0, 0, 0, 0);
SDL_FillRect (rect, NULL, param->in);
pos->x += 3;
pos->y += 3;
SDL_BlitSurface (rect, NULL, window, pos);
SDL_FreeSurface (rect);
pos->x -= 3;
pos->y -= 3;
}
#define NBOPTIONS 4
void Redim_entry (SDL_Surface** entry, int rayon, int l)
{
@ -35,7 +22,7 @@ void Redim_entry (SDL_Surface** entry, int rayon, int l)
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, 32, 0, 0, 0, 0);
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_RenderText_Blended(font, title, c);
@ -44,31 +31,26 @@ SDL_Surface* Incruste (SDL_Surface* hex, char* title, int l, TTF_Font* font, SDL
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_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, int xorig)
void Case_menu (menu_t m, int rayon)
{
char* police = "ressources/KeepCalm-Medium.ttf";
TTF_Font *fontMenu = TTF_OpenFont(police, rayon - 20);
if (fontMenu == NULL)
{
perror (police);
exit (1);
}
SDL_Color fontColor = {100, 100, 100};
int l;
SDL_Surface* hex = SDL_CreateRGBSurface (SDL_HWSURFACE, 2*rayon, 2*rayon, 32, 0, 0, 0, 0);
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, "Charger", l, fontMenu, fontColor);
SDL_Surface* hex_entry = Incruste(hex, "Charger", l, param->font, fontColor);
SDL_BlitSurface (hex_entry, NULL, m->window, &position);
SDL_FreeSurface (hex_entry);
@ -80,7 +62,7 @@ void case_menu (menu_t m, int rayon, int xorig)
/* Option */
dx = xorig + 2 * (l + 1) - rayon + l/2 + 1;
position.x = dx + 1 * (l + 1) / 2;
hex_entry = Incruste(hex, "Options", l, fontMenu, fontColor);
hex_entry = Incruste(hex, "Options", l, param->font, fontColor);
SDL_BlitSurface (hex_entry, NULL, m->window, &position);
SDL_FreeSurface (hex_entry);
@ -90,52 +72,40 @@ void case_menu (menu_t m, int rayon, int xorig)
{
position.x = dx + j * (l + 1) / 2;
position.y = 0 + j * (1.5 * rayon);
hex_entry = Incruste(hex, entry[j], l, fontMenu, fontColor);
hex_entry = Incruste(hex, entry[j], l, param->font, fontColor);
SDL_BlitSurface (hex_entry, NULL, m->window, &position);
SDL_FreeSurface (hex_entry);
}
SDL_FreeSurface(hex);
TTF_CloseFont (fontMenu);
}
/* Externes */
/* Menu */
void Affiche_menu_principal (menu_t m)
{
int width = m->window->w - 0;
int height = m->window->h - 0;
int width = m->window->w - 20;
int height = m->window->h * 11. / 12;
height -= height/12;
int r1 = width / (4 * RAC3);
int r1 = width / (3 * RAC3);
int r2 = height / 5;
int xorig = 0;
if (r1 < r2)
r1 = r1 - r1 % 2;
else
{
xorig = (width - 4 * RAC3 * r2) / 2;
r1 = r2 - r2 % 2;
}
case_menu (m, r1, xorig);
Case_menu (m, r1);
Affiche_entry(m, "HEX", POINTE);
SDL_Flip (m->window);
}
void Affiche_entry (menu_t m, char* entry, bool pointe)
{
char* police = "ressources/KeepCalm-Medium.ttf";
TTF_Font *font = TTF_OpenFont(police, m->r - 20);
if (font == NULL)
{
perror (police);
exit (1);
}
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, 32, 0, 0, 0, 0);
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)
@ -148,8 +118,214 @@ void Affiche_entry (menu_t m, char* entry, bool pointe)
Hexagon (hex, m->r, param->ex, param->in, 10, &(m->l));
c.r = 100; c.g = 100; c.b = 100;
}
hex_entry = Incruste (hex, entry, m->l, font, c);
hex_entry = Incruste (hex, entry, m->l, param->font, c);
SDL_FreeSurface (hex);
SDL_BlitSurface (hex_entry, NULL, m->window, &position);
SDL_FreeSurface (hex_entry);
SDL_Flip (m->window);
TTF_CloseFont (font);
}
/* Menu options */
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 = {(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);
int size = pos.h * 2 / 3. / NBOPTIONS;
int margev = pos.h / 3. / (NBOPTIONS + 1);
char* entry_name [NBOPTIONS] = {"Musique : ", "Couleurs : ", "Taille : ", "Retour"};
pos.y += margev;
pos.w -= 40;
pos.x += 10;
int maxw = 0;
SDL_Surface* entry [NBOPTIONS];
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;
}
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);
putPixel(window, pos_entry.x + pos_entry.w, pos_entry.y, SDL_MapRGB (window->format, 0, 255, 0));
pos.y += size + margev;
SDL_FreeSurface (entry_dim);
}
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);
pos.y += size + margev;
SDL_FreeSurface (entry_dim);
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);
}
/* Scroll */
/*typedef struct s_scrolling {
SDL_Surface* msg [NBMESS];
SDL_Rect* pos;
SDL_Rect* dim;
int first_msg, nb_msg, nb_msg_max;
}* scrolling_t;*/
scrolling_t init_scroll (SDL_Surface* window)
{
char* message [NBMESS] = {"Crédits : petite bite & gros chakal Corp.", "Breaking News : Le Soudan en manque de soudeurs", "lmqsdkmq"};
SDL_Color c [NBMESS] = {{170,10,107}, {60,255,1}, {0, 0, 0}};
scrolling_t s = malloc (sizeof (struct s_scrolling));
/* Bande de scroll */
int size = window->h / 24;
SDL_Rect bande = {0, window->h * 45. / 48, window->w, size};
SDL_FillRect (window, &bande, param->in);
SDL_Flip (window);
/* Creation surfaces */
for (int i = 0; i < NBMESS; ++i)
{
assert (message [i] != NULL);
SDL_Surface* texte = TTF_RenderUTF8_Blended(param->font, message [i], c [i]);//, param->rgb_ex);
Redim_entry(&texte, size, texte->w);
s->msg [i] = SDL_CreateRGBSurface (SDL_HWSURFACE, texte->w + 1, texte->h, window->format->BitsPerPixel, 0, 0, 0, 0);
SDL_Rect temp = {0, 0, s->msg [i]->w, s->msg [i]->h};
SDL_FillRect (s->msg [i], &temp, param->in);
SDL_BlitSurface (texte, NULL, s->msg [i], &temp);
SDL_FreeSurface (texte);
}
s->nb_msg_max = 1;
for (int i = 0; i < NBMESS; ++i)
{
int nb_msg = 1;
int taille_cumule = s->msg [i]->w;
while (window->w > taille_cumule)
{
taille_cumule += s->msg [(i + nb_msg)%NBMESS]->w + 10;
++nb_msg;
}
if (s->nb_msg_max < nb_msg)
s->nb_msg_max = nb_msg;
}
++s->nb_msg_max;
s->nb_msg_max += s->nb_msg_max % NBMESS;
s->pos = malloc (sizeof (SDL_Rect) * s->nb_msg_max);
s->dim = malloc (sizeof (SDL_Rect) * s->nb_msg_max);
for (int i = 0; i < s->nb_msg_max; ++i)
{
s->pos [i].x = window->w;
s->pos [i].y = window->h * 45. / 48;
s->dim [i].x = 0;
s->dim [i].y = 0;
s->dim [i].w = s->msg [i%NBMESS]->w;
s->dim [i].h = s->msg [i%NBMESS]->h;
}
s->first_msg = 0;
s->nb_msg = 1;
return s;
}
void free_scroll (scrolling_t s)
{
free (s->pos);
free (s->dim);
for (int i = 0; i < NBMESS; ++i)
SDL_FreeSurface(s->msg [i]);
free (s);
}
SDL_Event scroll_msg (SDL_Surface* window, scrolling_t s)
{
SDL_Event event;
bool delay;
while ((delay = !SDL_PollEvent(&event)))
{
for (int i = s->first_msg; i < s->first_msg + s->nb_msg; ++i)
{
int c = i % (s->nb_msg_max);
SDL_BlitSurface (s->msg [c % NBMESS], s->dim + c, window, s->pos + c);
s->pos [c].x -= 1;
if (s->pos [c].x == -1)
s->dim [c].x += 1;
}
if (s->dim [s->first_msg].x == s->msg [s->first_msg%NBMESS]->w)
{
s->dim [s->first_msg].x = 0;
s->pos [s->first_msg].x = window->w;
s->first_msg = (s->first_msg + 1) % (s->nb_msg_max);
--(s->nb_msg);
}
int last = (s->first_msg + s->nb_msg - 1) % (s->nb_msg_max);
if (s->pos[last].x + s->msg [last%NBMESS]->w - s->dim[last].x < window->w - 20 && s->nb_msg < s->nb_msg_max)
s->nb_msg = (s->nb_msg + 1) % ((s->nb_msg_max) + 1);
SDL_Flip(window);
if (delay)
SDL_Delay(5);
}
return event;
}

15
src/affichage_menu_principal.h
View File

@ -4,8 +4,23 @@
#include <SDL/SDL.h>
#include "globals.h"
#define NBMESS 3
typedef struct s_scrolling {
SDL_Surface* msg [NBMESS];
SDL_Rect* pos;
SDL_Rect* dim;
int first_msg, nb_msg, nb_msg_max;
}* scrolling_t;
void Affiche_menu_principal (menu_t m);
void Affiche_entry (menu_t m, char* entry, bool pointe);
scrolling_t init_scroll (SDL_Surface* window);
void free_scroll (scrolling_t s);
SDL_Event scroll_msg (SDL_Surface* window, scrolling_t s);
#endif /* _AFFICHAGE_MENU_PRICIPAL_ */

10
src/affichage_plateau.c
View File

@ -12,7 +12,7 @@
void Quadrille (plateau_t p)
{
SDL_Surface* hex = SDL_CreateRGBSurface (SDL_HWSURFACE, 2 * p->r, 2 * p->r, 32, 0, 0, 0, 0);
SDL_Surface* hex = SDL_CreateRGBSurface (SDL_HWSURFACE, 2 * p->r, 2 * p->r, p->window->format->BitsPerPixel, 0, 0, 0, 0);
Hexagon (hex, p->r, param->ex, param->in, DBORD, &(p->l));
for (int i = 0; i < NBSIDE; ++i)
{
@ -29,9 +29,9 @@ void Quadrille (plateau_t p)
void Quadrille_bis (plateau_t p)
{
SDL_Surface* hex = SDL_CreateRGBSurface (SDL_HWSURFACE, 2 * p->r, 2 * p->r, 32, 0, 0, 0, 0);
SDL_Surface* hex1 = SDL_CreateRGBSurface (SDL_HWSURFACE, 2 * p->r, 2 * p->r, 32, 0, 0, 0, 0);
SDL_Surface* hex2 = SDL_CreateRGBSurface (SDL_HWSURFACE, 2 * p->r, 2 * p->r, 32, 0, 0, 0, 0);
SDL_Surface* hex = SDL_CreateRGBSurface (SDL_HWSURFACE, 2 * p->r, 2 * p->r, p->window->format->BitsPerPixel, 0, 0, 0, 0);
SDL_Surface* hex1 = SDL_CreateRGBSurface (SDL_HWSURFACE, 2 * p->r, 2 * p->r, p->window->format->BitsPerPixel, 0, 0, 0, 0);
SDL_Surface* hex2 = SDL_CreateRGBSurface (SDL_HWSURFACE, 2 * p->r, 2 * p->r, p->window->format->BitsPerPixel, 0, 0, 0, 0);
Hexagon (hex, p->r, param->ex, param->in, DBORD, &(p->l));
Hexagon (hex1, p->r, param->ex, param->in, DBORD, &(p->l));
Circle (hex1, p->l, param->j2);
@ -88,7 +88,7 @@ void define_rayon (plateau_t p)
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)};
SDL_Surface* hex = SDL_CreateRGBSurface (SDL_HWSURFACE, 2 * p->r, 2 * p->r, 32, 0, 0, 0, 0);
SDL_Surface* hex = SDL_CreateRGBSurface (SDL_HWSURFACE, 2 * p->r, 2 * p->r, p->window->format->BitsPerPixel, 0, 0, 0, 0);
Uint32 c;
switch (state)
{

34
src/draw.c
View File

@ -49,19 +49,13 @@ void putPixel(SDL_Surface * surface, Uint16 x, Uint16 y, Uint32 color)
void Central_Square (SDL_Surface* hex, int* x, int* y, Uint32 color, int r)
{
int width = x[0] - x[2];
int height = r;//y[2] - y[3];
SDL_Surface* square = SDL_CreateRGBSurface (SDL_HWSURFACE, width, height, 32, 0, 0, 0, 0);
SDL_FillRect (square, NULL, color);
SDL_Rect position = {x[3], y[3]};
SDL_BlitSurface (square, NULL, hex, &position);
SDL_FreeSurface (square);
SDL_Rect position = {x[3], y[3], x[0] - x[2], r};
SDL_FillRect (hex, &position, color);
}
void Triangles (SDL_Surface* hex, int* x, int* y, Uint32 color, int r)
{
int h = r/2;//y[1] - y[2];
int h = r/2;
int l = (x[0] - x[2])/2;
SDL_LockSurface (hex);
for (int j = 0; j < h; ++j)
@ -73,6 +67,27 @@ void Triangles (SDL_Surface* hex, int* x, int* y, Uint32 color, int r)
SDL_UnlockSurface (hex);
}
void Hexagon_single (SDL_Surface* hex, int rayon, Uint32 color, int* l)
{
if (color == SDL_MapRGB(hex->format, 0, 0, 0))
{
SDL_FillRect (hex, NULL, SDL_MapRGB(hex->format, 100, 100, 100));
SDL_SetColorKey (hex , SDL_SRCCOLORKEY, SDL_MapRGB(hex->format, 100, 100, 100));
}
else
SDL_SetColorKey (hex , SDL_SRCCOLORKEY, SDL_MapRGB(hex->format, 0, 0, 0));
int x [4];
int y [4];
for (int i = 0; i < 4; ++i)
{
x [i] = cos(i * PI/3 + PI/6) * rayon + rayon;
y [i] = sin(i * PI/3 + PI/6) * rayon + rayon;
}
*l = x[0] - x[2];
Central_Square (hex, x, y, color, rayon);
Triangles (hex, x, y, color, rayon);
}
void Hexagon (SDL_Surface* hex, int rayon, Uint32 color_out, Uint32 color_in, int bord, int* l)
{
int x [4];
@ -92,7 +107,6 @@ void Hexagon (SDL_Surface* hex, int rayon, Uint32 color_out, Uint32 color_in, in
}
Central_Square (hex, x, y, color_in, rayon - bord);
Triangles (hex, x, y, color_in, rayon - bord);
SDL_Flip (hex);
SDL_SetColorKey (hex , SDL_SRCCOLORKEY, SDL_MapRGB(hex->format, 0, 0, 0)); // set black as transparent
}

2
src/draw.h
View File

@ -16,6 +16,8 @@ void Central_Square (SDL_Surface* hex, int* x, int* y, Uint32 color, int r);
void Triangles (SDL_Surface* hex, int* x, int* y, Uint32 color, int r);
void Hexagon_single (SDL_Surface* hex, int rayon, Uint32 color, int* l);
void Hexagon (SDL_Surface* hex, int rayon, Uint32 color_out, Uint32 color_in, int bord, int* l);
void Circle (SDL_Surface* hex, int l, Uint32 color);

13
src/error.c Normal file
View File

@ -0,0 +1,13 @@
/*
* error.c
*
* Created on: 21 avr. 2016
* Author: nathan
*/
#include "error.h"
void hex_error (char* msg, bool quit)
{
}

16
src/error.h Normal file
View File

@ -0,0 +1,16 @@
/*
* error.h
*
* Created on: 21 avr. 2016
* Author: nathan
*/
#ifndef _ERROR_H_
#define _ERROR_H_
#include <stdbool.h>
#define ERR_SDLINIT 1
#define ERR_TTFINIT 2
#endif /* _ERROR_H_ */

7
src/globals.h
View File

@ -2,10 +2,13 @@
#define _GLOBALS_H_
#include <SDL/SDL.h>
#include <SDL/SDL_ttf.h>
#include <SDL/SDL_mixer.h>
#include <stdbool.h>
#define DWIDTH 800
#define DHEIGHT 600
#define NBSIDE 11
#define PI 3.14159265
@ -57,8 +60,8 @@ typedef struct s_plateau {
typedef struct s_param {
Uint32 in, ex, j1, j2, background;
SDL_Color rgb_in, rgb_ex, rgb_j1, rgb_j2, rgb_background;
TTF_Font* font;
Mix_Music* click;
}* param_t;
void sleep_ms(int milliseconds);
#endif /* _GLOBALS_H_ */

28
src/hex.c
View File

@ -10,43 +10,21 @@
#include "en_jeu.h"
#include "param.h"
#ifdef WIN32
#include <windows.h>
#elif _POSIX_C_SOURCE >= 199309L
#include <time.h> // for nanosleep
#else
#include <unistd.h> // for usleep
#endif
void sleep_ms(int milliseconds) // cross-platform sleep function
{
#ifdef WIN32
Sleep(milliseconds);
#elif _POSIX_C_SOURCE >= 199309L
struct timespec ts;
ts.tv_sec = milliseconds / 1000;
ts.tv_nsec = (milliseconds % 1000) * 1000000;
nanosleep(&ts, NULL);
#else
usleep(milliseconds * 1000);
#endif
}
int main(int argc, char **argv)
{
SDL_Surface* window = init_window();
load_param(window);
Background (window);
Reset_window (window);
bool end = 0;
while (!end)
{
int retour = menu_principal(window);
reset_window(window);
Reset_window(window);
switch (retour)
{
case M_JOUER:
en_jeu (window);
reset_window(window);
Reset_window(window);
break;
case M_QUITTER:
end = 1;

224
src/menu_principal.c
View File

@ -1,12 +1,20 @@
#include "menu_principal.h"
#include <math.h>
#include "action_menu_principal.h"
#include "affichage_menu_principal.h"
#include "globals.h"
#include "window.h"
menu_t init_menu (SDL_Surface* window)
menu_t init_menu_principal (SDL_Surface* window)
{
menu_t m = malloc (sizeof (struct s_menu));
m->window = window;
m->cur.x = 1;
m->cur.y = 1;
return m;
}
menu_t init_menu_options (SDL_Surface* window)
{
menu_t m = malloc (sizeof (struct s_menu));
m->window = window;
@ -20,163 +28,73 @@ void free_menu (menu_t m)
free (m);
}
void deplacement_menu (menu_t m, SDL_Event* event)
scrolling_t resize_scroll (SDL_Surface* w, scrolling_t s)
{
char* entries [3][3] = {{"", "Charger", ""}, {"Jouer", "HEX", "Quitter"}, {"", "Options", ""}};
switch (event->type)
{
case SDL_MOUSEMOTION:
{
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, entries [m->cur.x][m->cur.y], NORMAL);
m->cur.x = hex.x;
m->cur.y = hex.y;
Affiche_entry(m, entries [hex.x][hex.y], POINTE);
}
break;
}
case SDL_KEYDOWN:
while (!SDL_PollEvent(event))
{
Affiche_entry(m, entries [m->cur.x][m->cur.y], NORMAL);
switch (event->key.keysym.sym)
{
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, entries [m->cur.x][m->cur.y], POINTE);
sleep_ms (200);
}
break;
}
free_scroll (s);
s = init_scroll (w);
return s;
}
bool selection_menu (menu_t m, int* r)
int menu_options (SDL_Surface* window, scrolling_t s, menu_t m)
{
switch (10 * m->cur.x + m->cur.y)
{
case 01:
*r = M_CHARGER;
return true;
case 10:
*r = M_JOUER;
return true;
case 11:
*r = M_HEX;
return false;
case 12:
*r = M_QUITTER;
return true;
case 21:
*r = M_OPTIONS;
return true;
default:
return false;
}
}
int menu_principal (SDL_Surface* window)
{
SDL_Event event;
menu_t m = init_menu(window);
Affiche_menu_principal(m);
int retour;
int end = 0;
while (!end)
Affiche_menu_options (window, m->r, m->l);
bool end = 0;
/*while (!end)
{
SDL_Event event;
SDL_WaitEvent (&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;
}
}*/
}
int menu_principal (SDL_Surface* window)
{
menu_t m = init_menu_principal (window);
Affiche_menu_principal(m);
int retour;
bool end = 0;
scrolling_t scroll = init_scroll (window);
while (!end)
{
SDL_Event event;
event = scroll_msg (window, scroll);
switch (event.type)
{
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)
@ -188,6 +106,7 @@ int menu_principal (SDL_Surface* window)
{
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);
@ -205,7 +124,14 @@ int menu_principal (SDL_Surface* window)
end = 1;
break;
}
if (retour == M_OPTIONS)
{
menu_options (window, scroll, m);
retour = -1;
}
}
free_menu(m);
free_scroll (scroll);
return retour;
}

51
src/param.c
View File

@ -8,6 +8,9 @@
#include "param.h"
#include <stdio.h>
#include <sys/stat.h>
#include <SDL/SDL_ttf.h>
#include <SDL/SDL_mixer.h>
#define C_IN SDL_MapRGB (w->format, 50, 50, 50)
#define C_EX SDL_MapRGB (w->format, 100, 100, 100)
@ -15,6 +18,8 @@
#define C_J2 SDL_MapRGB (w->format, 0, 0, 255)
#define C_BACKGROUND SDL_MapRGB (w->format, 0, 0, 0)
#define F_FONT "ressources/KeepCalm-Medium.ttf"
void load_param (SDL_Surface* w)
{
Uint32 c_default [5] = {C_IN, C_EX, C_J1, C_J2, C_BACKGROUND};
@ -31,10 +36,17 @@ void load_param (SDL_Surface* w)
rgb += 1;
c += 1;
}
param->font = TTF_OpenFont(F_FONT, 100);
if (param->font == NULL)
{
perror (F_FONT);
exit (1);
}
}
else
{
char buffer [100];
char police [BUFSIZ] = "";
SDL_Color* rgb = &(param->rgb_in);
Uint32* c = &(param->in);
fscanf (param_file, "%s\n", buffer);
@ -55,14 +67,30 @@ void load_param (SDL_Surface* w)
rgb += 1;
c += 1;
}
fscanf (param_file, "%s", buffer);
fscanf (param_file, "%s = %s", buffer, police);
struct stat i_dont_care;
if (!strcmp (police,"") || stat (police, &i_dont_care))
strcpy (police, F_FONT);
param->font = TTF_OpenFont(police, 100);
if (param->font == NULL)
{
perror (police);
exit (1);
}
fclose (param_file);
}
param->click = Mix_LoadMUS("ressources/Click03.wav");
}
void save_param (SDL_Surface* w)
{
FILE* param_file = fopen ("default", "w");
fprintf (param_file, "color\n");
FILE* param_file = fopen ("default", "r+");
if (param_file == NULL)
param_file = fopen ("default", "w+");
fprintf (param_file, "Colors\n");
char* field [5] = {"in", "ex", "j1", "j2", "background",};
SDL_Color* rgb = &(param->rgb_in);
for (int i = 0; i < 5 ; ++i)
@ -71,6 +99,25 @@ void save_param (SDL_Surface* w)
//printf ("%d - %d - %d\n", rgb->r, rgb->g, rgb->b);
rgb += 1;
}
fprintf (param_file, "Police\n");
char buffer [100] = "";
char police [BUFSIZ] = "";
int readed = fscanf (param_file, "%s = %s\n", buffer, police);
if (strcmp(police, F_FONT))
{
struct stat i_dont_care;
if (stat (police, &i_dont_care))
{
if (readed == 2)
fseek (param_file, -strlen(buffer) - strlen(police) - 3, SEEK_CUR);
else if (readed == 1)
fseek (param_file, -strlen(buffer), SEEK_CUR);
fprintf (param_file, "police = %s", F_FONT);
}
}
free (param);
fclose (param_file);
Mix_FreeMusic(param->click);
}

88
src/window.c
View File

@ -2,6 +2,7 @@
#include <SDL/SDL.h>
#include <SDL/SDL_ttf.h>
#include <SDL/SDL_mixer.h>
#include "globals.h"
#include "param.h"
@ -9,21 +10,41 @@
SDL_Surface* init_window ()
{
if (SDL_Init (SDL_INIT_VIDEO))
fprintf (stderr, "Erreur d'inistialisation SDL : %s\n", SDL_GetError());
{
fprintf (stderr, "SDL_Init failed : %s\n", SDL_GetError());
exit (1);
}
if (TTF_Init ())
fprintf (stderr, "Erreur d'inistialisation SDL_ttf : %s\n", SDL_GetError());
{
fprintf (stderr, "TTF_Init failed : %s\n", SDL_GetError());
exit (2);
}
SDL_Surface* window = SDL_SetVideoMode (DWIDTH, DHEIGHT, SDL_GetVideoInfo()->vfmt->BitsPerPixel, SDL_HWSURFACE | SDL_RESIZABLE | SDL_DOUBLEBUF);
SDL_WM_SetIcon (SDL_LoadBMP("ressources/ico.bmp"), NULL);
SDL_WM_SetCaption ("HEX (...a saute !)", "");
if(Mix_OpenAudio(44100, MIX_DEFAULT_FORMAT, MIX_DEFAULT_CHANNELS, 1024) == -1)
fprintf(stderr, "Mix init failed : %s\n", Mix_GetError());
const SDL_VideoInfo* info = SDL_GetVideoInfo();
int bpp;
if (info == NULL)
{
fprintf (stderr, "Unable to get video information\n Trying to force BPP to 8.\n");
bpp = 8;
}
else
bpp = info->vfmt->BitsPerPixel;
SDL_Surface* window = SDL_SetVideoMode (DWIDTH, DHEIGHT, bpp, SDL_HWSURFACE | SDL_RESIZABLE | SDL_DOUBLEBUF);
if (window == NULL)
{
fprintf (stderr, "Unable to set video mode : %s\n", SDL_GetError());
exit (3);
}
return window;
}
void Background (SDL_Surface* window)
{
SDL_FillRect (window, NULL, param->background);
SDL_Flip (window);
}
SDL_Surface* resize_window (SDL_Surface* window, SDL_Event* event)
{
int w = event->resize.w, h = event->resize.h;
@ -32,12 +53,25 @@ SDL_Surface* resize_window (SDL_Surface* window, SDL_Event* event)
w = event->resize.w;
h = event->resize.h;
}
printf ("%d - %d\n", w, h);
SDL_FreeSurface (window);
if (w >= DWIDTH && h >= DHEIGHT)
window = SDL_SetVideoMode(w, h, SDL_GetVideoInfo()->vfmt->BitsPerPixel, SDL_HWSURFACE | SDL_RESIZABLE | SDL_DOUBLEBUF);
const SDL_VideoInfo* info = SDL_GetVideoInfo();
int bpp;
if (info == NULL)
{
fprintf (stderr, "Unable to get video information\n Trying to force BPP to 8.\n");
bpp = 8;
}
else
window = SDL_SetVideoMode (DWIDTH, DHEIGHT, SDL_GetVideoInfo()->vfmt->BitsPerPixel, SDL_HWSURFACE | SDL_RESIZABLE | SDL_DOUBLEBUF);
bpp = info->vfmt->BitsPerPixel;
if (w >= DWIDTH && h >= DHEIGHT)
window = SDL_SetVideoMode(w, h, bpp, SDL_HWSURFACE | SDL_RESIZABLE | SDL_DOUBLEBUF);
else
window = SDL_SetVideoMode (DWIDTH, DHEIGHT, bpp, SDL_HWSURFACE | SDL_RESIZABLE | SDL_DOUBLEBUF);
if (window == NULL)
{
fprintf (stderr, "Unable to set video mode : %s\n", SDL_GetError());
exit (3);
}
SDL_FillRect (window, NULL, param->background);
SDL_Flip (window);
return window;
@ -45,9 +79,19 @@ SDL_Surface* resize_window (SDL_Surface* window, SDL_Event* event)
SDL_Surface* fullscreen_window (SDL_Surface* window)
{
const SDL_VideoInfo* info = SDL_GetVideoInfo();
int bpp;
if (info == NULL)
{
fprintf (stderr, "Unable to get video information\n Trying to force BPP to 8.\n");
bpp = 8;
}
else
bpp = info->vfmt->BitsPerPixel;
if (window->flags & SDL_FULLSCREEN)
{
window = SDL_SetVideoMode (DWIDTH, DHEIGHT, SDL_GetVideoInfo()->vfmt->BitsPerPixel, SDL_HWSURFACE | SDL_RESIZABLE | SDL_DOUBLEBUF);
window = SDL_SetVideoMode (DWIDTH, DHEIGHT, bpp, SDL_HWSURFACE | SDL_RESIZABLE | SDL_DOUBLEBUF);
}
else
{
@ -55,7 +99,6 @@ SDL_Surface* fullscreen_window (SDL_Surface* window)
if(modes == (SDL_Rect **)0)
{
printf("No modes available!\n");
exit(-1);
}
/* Check if our resolution is restricted */
@ -64,20 +107,25 @@ SDL_Surface* fullscreen_window (SDL_Surface* window)
printf("All resolutions available.\n");
}
else{
/* Print valid modes */
/* Print valid modes
printf("Available Modes\n");
for(int i=0;modes[i];++i)
printf(" %d x %d\n", modes[i]->w, modes[i]->h);
printf(" %d x %d\n", modes[i]->w, modes[i]->h);*/
SDL_FreeSurface (window);
window = SDL_SetVideoMode(modes[0]->w, modes[0]->h, SDL_GetVideoInfo()->vfmt->BitsPerPixel, SDL_HWSURFACE | SDL_FULLSCREEN | SDL_DOUBLEBUF);
window = SDL_SetVideoMode(modes[0]->w, modes[0]->h, bpp, SDL_HWSURFACE | SDL_FULLSCREEN | SDL_DOUBLEBUF);
}
}
if (window == NULL)
{
fprintf (stderr, "Unable to set video mode : %s\n", SDL_GetError());
exit (3);
}
SDL_FillRect (window, NULL, param->background);
SDL_Flip (window);
return window;
}
void reset_window (SDL_Surface* window)
void Reset_window (SDL_Surface* window)
{
SDL_FillRect (window, NULL, param->background);
SDL_Flip (window);

4
src/window.h
View File

@ -5,12 +5,10 @@
SDL_Surface* init_window ();
void Background (SDL_Surface* window);
SDL_Surface* resize_window (SDL_Surface* window, SDL_Event* event);
SDL_Surface* fullscreen_window (SDL_Surface* window);
void reset_window (SDL_Surface* window);
void Reset_window (SDL_Surface* window);
#endif /* _WINDOW_H_ */