diff --git a/bin/hex b/bin/hex index 2fb79e4..f9bc9a0 100644 Binary files a/bin/hex and b/bin/hex differ diff --git a/makefile b/makefile index a780255..8857fa3 100644 --- a/makefile +++ b/makefile @@ -1,8 +1,8 @@ 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 +LDFLAGS=-std=c99 -lm `sdl-config --cflags --libs` -lSDL_ttf -lSDL_gfx EXEC=bin/hex -SRC=src/hex.c src/affichage_plateau.c src/action_plateau.c src/affichage_menu_principal.c src/window.c src/en_jeu.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 #$(wildcard src/*.c) OBJ=$(SRC:.c=.o) diff --git a/ressources/BebasNeue.otf b/ressources/BebasNeue.otf new file mode 100644 index 0000000..214e007 Binary files /dev/null and b/ressources/BebasNeue.otf differ diff --git a/ressources/KeepCalm-Medium.ttf b/ressources/KeepCalm-Medium.ttf new file mode 100644 index 0000000..5b16cc5 Binary files /dev/null and b/ressources/KeepCalm-Medium.ttf differ diff --git a/ressources/KeepCalm_ReadMe.pdf b/ressources/KeepCalm_ReadMe.pdf new file mode 100644 index 0000000..5532b49 Binary files /dev/null and b/ressources/KeepCalm_ReadMe.pdf differ diff --git a/ressources/License.txt b/ressources/License.txt new file mode 100644 index 0000000..7476de8 --- /dev/null +++ b/ressources/License.txt @@ -0,0 +1,37 @@ +____________________________________________________________________________________________________ + _____ _ _ __ ____ _ _ __ ______ _ _ ____ _____ + / ) / / / | / ) / /| / | / | / / ) / ' +---/----/----/___ /-----/__|----/___ /----/| /-|----/__|--------/--------|---/-----/____/----/__---- + / / / / / | / | / |/ | / | / | / / / +_/____/____/____/_____/____|__/_____|___/__/___|__/____|______/__________|_/_____/_________/____ ___ + / + (_ / DHARMA TYPE FREE FONTs + + +This Font Software is licensed under the SIL Open Font License, Version 1.1 + +FAQ + +Q_ Can I use this for a commercial product? +A_ Yes + +Q_ Can I use this on a web page via css @font-face? +A_ Yes + +Q_ Can I donate $ to you? +A_ Yes, You can! ( Paypal: info@dharmatype.com ) + + + +Contact_______________________________ + +info@dharmatype.com + +Dharma Type (http://dharmatype.com) + | + |___ Flat it type foundry + | + |___ Prop-a-ganda + | + |___ Holiday Type +______________________________________ \ No newline at end of file diff --git a/src/action_plateau.c b/src/action_plateau.c index 1b6658a..176e6bf 100644 --- a/src/action_plateau.c +++ b/src/action_plateau.c @@ -1,11 +1,27 @@ -//#include "action_plateau.h" - -#include -#include - #include "action_plateau.h" -#define RAC3 1.73205080757 +#include +#include + +#include "affichage_plateau.h" +#include "globals.h" + +void selection (plateau_t p, curseur_t c) +{ + if (0 <= c.x && c.x < NBSIDE && 0 <= c.y && c.y < NBSIDE && p->grid [c.x * NBSIDE + c.y] == 0) + { + p->grid [c.x * NBSIDE + c.y] = PLAYER(p->player); + p->player = !p->player; + Affiche_hexagon(p, c.x, c.y, PLAYER(p->player)); + } + /*for (int x = 0; x < NBSIDE; ++x) + { + for (int y = 0; y < NBSIDE; ++y) + printf ("%d ", p->grid [y * NBSIDE + x]); + printf ("\n"); + } + printf ("\n");*/ +} void deplacement (plateau_t p, SDL_Event* event, curseur_t* c) { @@ -13,10 +29,10 @@ void deplacement (plateau_t p, SDL_Event* event, curseur_t* c) { case SDL_MOUSEMOTION: { - vec2 pos = {event->motion.x - (p->marge_hori + p->r - p->l/2 - 1), event->motion.y - (p->marge_vert + 1)}; - int ligne = round(pos.y / (1.5 * p->r + 1) - .5); + vec2 pos = {event->motion.x - (p->marge_hori + p->r - p->l/2 - 2), event->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 + 1)}; + vec2 relative = {pos.x % (p->l + 1), pos.y % (int)(1.5 * p->r)}; vec2 proj = {relative.y + relative.x / RAC3, relative.y - relative.x / RAC3}; vec2 hex; if (ligne % 2) @@ -70,7 +86,7 @@ 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, J1); + Affiche_hexagon(p, c->x, c->y, PLAYER(p->player)); } @@ -107,7 +123,7 @@ void deplacement (plateau_t p, SDL_Event* event, curseur_t* c) c->y = 0; if (c->y < 0) c->y = NBSIDE - 1; - Affiche_hexagon(p, c->x, c->y, J1); + Affiche_hexagon(p, c->x, c->y, PLAYER(p->player)); sleep_ms (100); } break; diff --git a/src/action_plateau.h b/src/action_plateau.h index 5662232..de10056 100644 --- a/src/action_plateau.h +++ b/src/action_plateau.h @@ -1,9 +1,12 @@ #ifndef _ACTION_PLATEAU_H_ #define _ACTION_PLATEAU_H_ -#include "affichage_plateau.h" +#include + #include "globals.h" +void selection (plateau_t p, curseur_t c); + void deplacement (plateau_t p, SDL_Event* event, curseur_t* c); #endif /* _ACTION_PLATEAU_H_ */ diff --git a/src/affichage_menu_principal.c b/src/affichage_menu_principal.c index 16d0d40..bf28b03 100644 --- a/src/affichage_menu_principal.c +++ b/src/affichage_menu_principal.c @@ -1,48 +1,155 @@ #include "affichage_menu_principal.h" -#include -#include "globals.h" +#include +#include +#include +#include "param.h" +#include "draw.h" -void Affiche_menu_principal (SDL_Surface* window) +void rectangle (SDL_Surface* window, SDL_Rect* pos) { - int width = window->w; - int height = window->h; - - SDL_Surface* entry; - - if (TTF_Init ()) //Check error - fprintf (stderr, "Erreur d'inistialisation SDL : %s\n", SDL_GetError()); - - SDL_Rect position = {0, 0}; - - SDL_Color fontColor = {255, 255, 255}; - - int size_titre = 10; - int size_entries = 22; - int margev_titre = 20; - int margev_entries = 4; - - /* Titre */ - - TTF_Font *fontMenu = TTF_OpenFont("ressources/cac_champagne.ttf",60); // charger une fonte (un peu moche) + 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; +} + +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, 32, 0, 0, 0, 0); + SDL_BlitSurface (hex, NULL, hex_entry, NULL); + + SDL_Surface* entry = TTF_RenderText_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, int xorig) +{ + char* police = "ressources/KeepCalm-Medium.ttf"; + TTF_Font *fontMenu = TTF_OpenFont(police, rayon - 20); if (fontMenu == NULL) { - perror ("camarche pas"); + perror (police); exit (1); - } - entry = TTF_RenderText_Blended(fontMenu, "HEX", fontColor); - position.x = window->w / 2 - size_titre * 3; - position.y = margev_titre; - - SDL_BlitSurface (entry, NULL, window, &position); - SDL_Flip (window); - //SDL_FreeSurface(entry); - - /* Jouer */ - //entry = SDL_CreateRGBSurface (SDL_HWSURFACE, , , window->format->BitsPerPixel, 0, 0, 0, 0); - //SDL_FillRect (entry, NULL, BPP_entries); - + } + SDL_Color fontColor = {100, 100, 100}; + + int l; + SDL_Surface* hex = SDL_CreateRGBSurface (SDL_HWSURFACE, 2*rayon, 2*rayon, 32, 0, 0, 0, 0); + Hexagon (hex, rayon, param->ex, param->in, 10, &l); + /* 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_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 */ - /* Quitter */ + dx = xorig + 2 * (l + 1) - rayon + l/2 + 1; + position.x = dx + 1 * (l + 1) / 2; + hex_entry = Incruste(hex, "Options", l, fontMenu, fontColor); + SDL_BlitSurface (hex_entry, NULL, m->window, &position); + SDL_FreeSurface (hex_entry); + + dx = xorig + 1 * (l + 1) - rayon + l/2 + 1; + char* entry [3] = {"Jouer", "HEX", "Quitter"}; + 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, entry[j], l, fontMenu, fontColor); + SDL_BlitSurface (hex_entry, NULL, m->window, &position); + SDL_FreeSurface (hex_entry); + } + + SDL_FreeSurface(hex); + TTF_CloseFont (fontMenu); +} + +void Affiche_menu_principal (menu_t m) +{ + int width = m->window->w - 0; + int height = m->window->h - 0; + + height -= height/12; + + int r1 = width / (4 * 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); + 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_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; + } + hex_entry = Incruste (hex, entry, m->l, font, c); + SDL_BlitSurface (hex_entry, NULL, m->window, &position); + SDL_Flip (m->window); + TTF_CloseFont (font); } diff --git a/src/affichage_menu_principal.h b/src/affichage_menu_principal.h index 52d2bcd..1a0112f 100644 --- a/src/affichage_menu_principal.h +++ b/src/affichage_menu_principal.h @@ -1,9 +1,11 @@ #ifndef _AFFICHAGE_MENU_PRICIPAL_ #define _AFFICHAGE_MENU_PRICIPAL_ -#include +#include +#include "globals.h" +void Affiche_menu_principal (menu_t m); -void Affiche_menu_principal (SDL_Surface* window); +void Affiche_entry (menu_t m, char* entry, bool pointe); #endif /* _AFFICHAGE_MENU_PRICIPAL_ */ diff --git a/src/affichage_plateau.c b/src/affichage_plateau.c index 2e571a1..9ed62ea 100644 --- a/src/affichage_plateau.c +++ b/src/affichage_plateau.c @@ -1,101 +1,19 @@ #include "affichage_plateau.h" -#include -#include #include +#include -#include "globals.h" +#include "param.h" +#include "draw.h" + +#define DBORD 4 /* Internes */ -/* source : http://www.gnurou.org/writing/linuxmag/sdl/partie1 */ - -void putPixel(SDL_Surface * surface, Uint16 x, Uint16 y, Uint32 color) -{ - /* Nombre de bits par pixels de la surface d'écran */ - Uint8 bpp = surface->format->BytesPerPixel; - /* Pointeur vers le pixel à remplacer (pitch correspond à la taille - d'une ligne d'écran, c'est à dire (longueur * bitsParPixel) - pour la plupart des cas) */ - Uint8 * p = ((Uint8 *)surface->pixels) + y * surface->pitch + x * bpp; - switch(bpp) - { - case 1: - *p = (Uint8) color; - break; - case 2: - *(Uint16 *)p = (Uint16) color; - break; - case 3: - if (SDL_BYTEORDER == SDL_BIG_ENDIAN) - { - *(Uint16 *)p = ((color >> 8) & 0xff00) | ((color >> 8) & 0xff); - *(p + 2) = color & 0xff; - } - else - { - *(Uint16 *)p = color & 0xffff; - *(p + 2) = ((color >> 16) & 0xff) ; - } - break; - case 4: - *(Uint32 *)p = color; - break; - } -} - -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); -} - -void Triangles (SDL_Surface* hex, int* x, int* y, Uint32 color, int r) -{ - int h = r/2;//y[1] - y[2]; - int l = (x[0] - x[2])/2; - SDL_LockSurface (hex); - for (int j = 0; j < h; ++j) - for (int i = - l * (h - j) / h; i <= l * (h - j) / h; ++i) - { - putPixel (hex, x[1] + i - 1, y[3] - j, color); - putPixel (hex, x[1] + i - 1, y[0] + j, color); - } - SDL_UnlockSurface (hex); -} - -void Hexagon (SDL_Surface* hex, int rayon, Uint32 color_out, Uint32 color_in, int* l) -{ - 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_out, rayon); - Triangles (hex, x, y, color_out, rayon); - for (int i = 0; i < 4; ++i) - { - x [i] = cos(i * PI/3 + PI/6) * (rayon - 4) + rayon; - y [i] = sin(i * PI/3 + PI/6) * (rayon - 4) + rayon; - } - Central_Square (hex, x, y, color_in, rayon - 4); - Triangles (hex, x, y, color_in, rayon - 4); - SDL_Flip (hex); - SDL_SetColorKey (hex , SDL_SRCCOLORKEY, SDL_MapRGB( hex->format, 0, 0, 0)); // set black as transparent -} void Quadrille (plateau_t p) { SDL_Surface* hex = SDL_CreateRGBSurface (SDL_HWSURFACE, 2 * p->r, 2 * p->r, 32, 0, 0, 0, 0); - Hexagon (hex, p->r, SDL_MapRGB (p->window->format, 100, 100, 100), SDL_MapRGB (p->window->format, 50, 50, 50), &(p->l)); + Hexagon (hex, p->r, param->ex, param->in, DBORD, &(p->l)); for (int i = 0; i < NBSIDE; ++i) { int dx = p->marge_hori + i * (p->l + 1); @@ -109,6 +27,42 @@ void Quadrille (plateau_t p) SDL_Flip (p->window); } +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); + 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); + Hexagon (hex2, p->r, param->ex, param->in, DBORD, &(p->l)); + Circle (hex2, p->l, param->j1); + for (int i = 0; i < NBSIDE; ++i) + { + int dx = p->marge_hori + i * (p->l + 1); + for (int j = 0; j < NBSIDE; ++j) + { + SDL_Rect position = {dx + j * (p->l + 1) / 2, p->marge_vert + j * (1.5 * p->r)}; + switch (p->grid[i * NBSIDE + j]) + { + case 0: + SDL_BlitSurface (hex, NULL, p->window, &position); + break; + case 1: + SDL_BlitSurface (hex1, NULL, p->window, &position); + break; + case 2: + SDL_BlitSurface (hex2, NULL, p->window, &position); + break; + } + } + } + SDL_FreeSurface(hex); + SDL_FreeSurface(hex1); + SDL_FreeSurface(hex2); + SDL_Flip (p->window); +} + void define_rayon (plateau_t p) { int decal_droite = 40; @@ -139,16 +93,25 @@ void Affiche_hexagon (plateau_t p, int x, int y, int state) switch (state) { case J1 : - c = SDL_MapRGB (p->window->format, 255, 0, 0); + c = param->j1; break; case J2 : - c = SDL_MapRGB (p->window->format, 0, 0, 255); + c = param->j2; break; case NORMAL : - c = SDL_MapRGB (p->window->format, 100, 100, 100); + c = param->ex; + break; + } + Hexagon (hex, p->r, c, param->in, DBORD, &(p->l)); + switch (p->grid[x * NBSIDE + y]) + { + case J1: + Circle (hex, p->l, param->j1); + break; + case J2: + Circle (hex, p->l, param->j2); break; } - Hexagon (hex, p->r, c, SDL_MapRGB (p->window->format, 50, 50, 50), &(p->l)); SDL_BlitSurface (hex, NULL, p->window, &position); SDL_FreeSurface (hex); SDL_Flip (p->window); @@ -157,7 +120,12 @@ void Affiche_hexagon (plateau_t p, int x, int y, int state) plateau_t init_plateau (SDL_Surface* window) { plateau_t p = malloc (sizeof (struct s_plateau)); + p->grid = malloc (sizeof (int) * NBSIDE * NBSIDE); + for (int x = 0; x < NBSIDE; ++x) + for (int y = 0; y < NBSIDE; ++y) + p->grid [x * NBSIDE + y] = 0; p->window = window; + p->player = false; define_rayon(p); Quadrille (p); return p; @@ -166,11 +134,12 @@ plateau_t init_plateau (SDL_Surface* window) plateau_t actu_plateau (plateau_t p) { define_rayon(p); - Quadrille (p); + Quadrille_bis (p); return p; } void free_plateau (plateau_t p) { + free (p->grid); free (p); } diff --git a/src/affichage_plateau.h b/src/affichage_plateau.h index 2423891..474eb7a 100644 --- a/src/affichage_plateau.h +++ b/src/affichage_plateau.h @@ -3,9 +3,11 @@ #include +#include "globals.h" + #define COLOR 32 -typedef struct s_plateau* plateau_t; +void putPixel(SDL_Surface * surface, Uint16 x, Uint16 y, Uint32 color); void Affiche_hexagon (plateau_t p, int x, int y, int state); diff --git a/src/draw.c b/src/draw.c new file mode 100644 index 0000000..ab108b9 --- /dev/null +++ b/src/draw.c @@ -0,0 +1,107 @@ +/* + * draw.c + * + * Created on: 18 avr. 2016 + * Author: nathan + */ + +#include "draw.h" + +#include + +#include "globals.h" + + +/* source : http://www.gnurou.org/writing/linuxmag/sdl/partie1 */ +void putPixel(SDL_Surface * surface, Uint16 x, Uint16 y, Uint32 color) +{ + /* Nombre de bits par pixels de la surface d'écran */ + Uint8 bpp = surface->format->BytesPerPixel; + /* Pointeur vers le pixel à remplacer (pitch correspond à la taille + d'une ligne d'écran, c'est à dire (longueur * bitsParPixel) + pour la plupart des cas) */ + Uint8 * p = ((Uint8 *)surface->pixels) + y * surface->pitch + x * bpp; + switch(bpp) + { + case 1: + *p = (Uint8) color; + break; + case 2: + *(Uint16 *)p = (Uint16) color; + break; + case 3: + if (SDL_BYTEORDER == SDL_BIG_ENDIAN) + { + *(Uint16 *)p = ((color >> 8) & 0xff00) | ((color >> 8) & 0xff); + *(p + 2) = color & 0xff; + } + else + { + *(Uint16 *)p = color & 0xffff; + *(p + 2) = ((color >> 16) & 0xff) ; + } + break; + case 4: + *(Uint32 *)p = color; + break; + } +} + +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); +} + +void Triangles (SDL_Surface* hex, int* x, int* y, Uint32 color, int r) +{ + int h = r/2;//y[1] - y[2]; + int l = (x[0] - x[2])/2; + SDL_LockSurface (hex); + for (int j = 0; j < h; ++j) + for (int i = - l * (h - j) / h; i <= l * (h - j) / h; ++i) + { + putPixel (hex, x[1] + i - 1, y[3] - j, color); + putPixel (hex, x[1] + i - 1, y[0] + j, color); + } + SDL_UnlockSurface (hex); +} + +void Hexagon (SDL_Surface* hex, int rayon, Uint32 color_out, Uint32 color_in, int bord, int* l) +{ + 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_out, rayon); + Triangles (hex, x, y, color_out, rayon); + for (int i = 0; i < 4; ++i) + { + x [i] = cos(i * PI/3 + PI/6) * (rayon - bord) + rayon; + y [i] = sin(i * PI/3 + PI/6) * (rayon - bord) + rayon; + } + 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 +} + +void Circle (SDL_Surface* hex, int l, Uint32 color) +{ + int r = (l - 6) / 2.5; + SDL_LockSurface (hex); + for (float j = 0; j < 2 * PI; j = j + 1. / (2*r)) + for (int i = 0; i < r; ++i) + putPixel (hex, i * cos (j) + hex->h / 2 - 1, i * sin (j) + hex->h / 2, color); + SDL_UnlockSurface (hex); +} diff --git a/src/draw.h b/src/draw.h new file mode 100644 index 0000000..7ba3036 --- /dev/null +++ b/src/draw.h @@ -0,0 +1,23 @@ +/* + * draw.h + * + * Created on: 18 avr. 2016 + * Author: nathan + */ + +#ifndef _DRAW_H_ +#define _DRAW_H_ + +#include + +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); + +void Triangles (SDL_Surface* hex, int* x, int* y, Uint32 color, int r); + +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); + +#endif /* _DRAW_H_ */ diff --git a/src/en_jeu.c b/src/en_jeu.c index 4e63f03..3eda482 100644 --- a/src/en_jeu.c +++ b/src/en_jeu.c @@ -15,8 +15,8 @@ void en_jeu (SDL_Surface* window) { plateau_t plateau = init_plateau (window); - vec2 c = {-1, -1}; - int end = 0; + vec2 c = {0, 0}; + bool end = 0; while (!end) { SDL_Event event; @@ -24,15 +24,9 @@ void en_jeu (SDL_Surface* window) switch (event.type) { case SDL_VIDEORESIZE: - { resize_window(window, &event); plateau = actu_plateau(plateau); break; - } - case SDL_MOUSEBUTTONDOWN: - { - break; - } case SDL_KEYDOWN: if (event.key.keysym.sym == SDLK_ESCAPE) end = 1; @@ -41,9 +35,14 @@ void en_jeu (SDL_Surface* window) window = fullscreen_window(window); plateau = actu_plateau(plateau); } + else if (event.key.keysym.sym == SDLK_RETURN) + selection (plateau, c); else if (SDLK_UP <= event.key.keysym.sym && event.key.keysym.sym <= SDLK_LEFT) deplacement(plateau, &event, &c); break; + case SDL_MOUSEBUTTONUP: + selection (plateau, c); + break; case SDL_MOUSEMOTION: deplacement(plateau, &event, &c); break; diff --git a/src/globals.h b/src/globals.h index 8a89f05..47c218f 100644 --- a/src/globals.h +++ b/src/globals.h @@ -1,14 +1,27 @@ #ifndef _GLOBALS_H_ #define _GLOBALS_H_ +#include +#include + #define DWIDTH 800 #define DHEIGHT 600 #define NBSIDE 11 -#define PI 3.14159265 +#define PI 3.14159265 +#define RAC3 1.73205080757 + +#define PLAYER(x) x + 1 #define J1 1 #define J2 2 #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 typedef struct s_vec3{ int x; @@ -23,13 +36,28 @@ typedef struct s_vec2{ typedef struct s_vec2 curseur_t; -struct s_plateau { +typedef struct s_menu { + int l; + int r; + vec2 pos; + vec2 cur; + SDL_Surface* window; +}* menu_t; + +typedef struct s_plateau { int l; int r; int marge_vert; int marge_hori; SDL_Surface* window; -}; + int *grid; + bool player; +}* plateau_t; + +typedef struct s_param { + Uint32 in, ex, j1, j2, background; + SDL_Color rgb_in, rgb_ex, rgb_j1, rgb_j2, rgb_background; +}* param_t; void sleep_ms(int milliseconds); diff --git a/src/hex.c b/src/hex.c index 9152d38..c2e7469 100644 --- a/src/hex.c +++ b/src/hex.c @@ -6,8 +6,9 @@ #include #include "window.h" #include "globals.h" -#include "affichage_menu_principal.h" +#include "menu_principal.h" #include "en_jeu.h" +#include "param.h" #ifdef WIN32 #include @@ -31,13 +32,28 @@ void sleep_ms(int milliseconds) // cross-platform sleep function #endif } -int main (void) +int main(int argc, char **argv) { SDL_Surface* window = init_window(); - //Affiche_menu_principal(window); - en_jeu (window); + load_param(window); + Background (window); + bool end = 0; + while (!end) + { + int retour = menu_principal(window); + reset_window(window); + switch (retour) + { + case M_JOUER: + en_jeu (window); + reset_window(window); + break; + case M_QUITTER: + end = 1; + } + } + save_param(window); SDL_FreeSurface (window); SDL_Quit (); - return 0; } diff --git a/src/menu_principal.c b/src/menu_principal.c index 33d6e7e..ffc8ba2 100644 --- a/src/menu_principal.c +++ b/src/menu_principal.c @@ -1,18 +1,211 @@ +#include "menu_principal.h" + +#include + +#include "affichage_menu_principal.h" +#include "globals.h" #include "window.h" -int event_menu_principal (SDL_Event* event) +menu_t init_menu (SDL_Surface* window) { - while (1) + 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); +} + +void deplacement_menu (menu_t m, SDL_Event* event) +{ + char* entries [3][3] = {{"", "Charger", ""}, {"Jouer", "HEX", "Quitter"}, {"", "Options", ""}}; + switch (event->type) { - SDL_WaitEvent (event); - 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) { - case SDL_MOUSEMOTION: - return 1; + 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 SDL_BUTTON_LEFT: + 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; + } +} + +bool selection_menu (menu_t m, int* r) +{ + 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) + { + SDL_Event event; + SDL_WaitEvent (&event); + switch (event.type) + { + case SDL_VIDEORESIZE: + resize_window(window, &event); + Affiche_menu_principal(m); + break; + case SDL_KEYDOWN: + if (event.key.keysym.sym == SDLK_ESCAPE) + { + retour = M_QUITTER; + end = 1; + } + else if (event.key.keysym.sym == SDLK_f) + { + window = fullscreen_window(window); + Affiche_menu_principal(m); + } + 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: + retour = M_QUITTER; + end = 1; break; } } - return -1; + free_menu(m); + return retour; } diff --git a/src/menu_principal.h b/src/menu_principal.h index 8b13789..8509082 100644 --- a/src/menu_principal.h +++ b/src/menu_principal.h @@ -1 +1,8 @@ +#ifndef _MENU_PRINCIPAL_H_ +#define _MENU_PRINCIPAL_H_ +#include + +int menu_principal (SDL_Surface* window); + +#endif /* _MENU_PRINCIPAL_H_ */ diff --git a/src/param.c b/src/param.c new file mode 100644 index 0000000..385b757 --- /dev/null +++ b/src/param.c @@ -0,0 +1,76 @@ +/* + * param.c + * + * Created on: 18 avr. 2016 + * Author: nathan + */ + +#include "param.h" + +#include + +#define C_IN SDL_MapRGB (w->format, 50, 50, 50) +#define C_EX SDL_MapRGB (w->format, 100, 100, 100) +#define C_J1 SDL_MapRGB (w->format, 255, 0, 0) +#define C_J2 SDL_MapRGB (w->format, 0, 0, 255) +#define C_BACKGROUND SDL_MapRGB (w->format, 0, 0, 0) + +void load_param (SDL_Surface* w) +{ + Uint32 c_default [5] = {C_IN, C_EX, C_J1, C_J2, C_BACKGROUND}; + FILE* param_file = fopen ("default", "r"); + param = malloc (sizeof (struct s_param)); + if (param_file == NULL) + { + SDL_Color* rgb = &(param->rgb_in); + Uint32* c = &(param->in); + for (int i = 0; i < 5; ++i) + { + *c = c_default [i]; + SDL_GetRGB(*c, w->format, &(rgb->r), &(rgb->g), &(rgb->b)); + rgb += 1; + c += 1; + } + } + else + { + char buffer [100]; + SDL_Color* rgb = &(param->rgb_in); + Uint32* c = &(param->in); + fscanf (param_file, "%s\n", buffer); + for (int i = 0; i < 5; ++i) + { + int r = -1, g = -1, b = -1; + fscanf (param_file, "%s = %d %d %d", buffer, &r, &g, &b); + if (0 > r || r > 255 || 0 > g || g > 255 || 0 > b || b > 255) + { + *c = c_default [i]; + SDL_GetRGB(*c, w->format, &(rgb->r), &(rgb->g), &(rgb->b)); + } + else + { + rgb->r = r; rgb->g = g; rgb->b = b; + *c = SDL_MapRGB (w->format, rgb->r, rgb->g, rgb->b); + } + rgb += 1; + c += 1; + } + fclose (param_file); + } +} + +void save_param (SDL_Surface* w) +{ + FILE* param_file = fopen ("default", "w"); + fprintf (param_file, "color\n"); + char* field [5] = {"in", "ex", "j1", "j2", "background",}; + SDL_Color* rgb = &(param->rgb_in); + for (int i = 0; i < 5 ; ++i) + { + fprintf (param_file, "%s = %d %d %d\n", field [i], rgb->r, rgb->g, rgb->b); + //printf ("%d - %d - %d\n", rgb->r, rgb->g, rgb->b); + rgb += 1; + } + free (param); + fclose (param_file); +} diff --git a/src/param.h b/src/param.h new file mode 100644 index 0000000..feef60a --- /dev/null +++ b/src/param.h @@ -0,0 +1,18 @@ +/* + * param.h + * + * Created on: 18 avr. 2016 + * Author: nathan + */ + +#ifndef _PARAM_H_ +#define _PARAM_H_ + +#include "globals.h" + +param_t param; + +void load_param (SDL_Surface* w); +void save_param (SDL_Surface* w); + +#endif /* _PARAM_H_ */ diff --git a/src/window.c b/src/window.c index f3ab506..2e04532 100644 --- a/src/window.c +++ b/src/window.c @@ -1,20 +1,29 @@ #include "window.h" #include +#include #include "globals.h" +#include "param.h" SDL_Surface* init_window () { if (SDL_Init (SDL_INIT_VIDEO)) fprintf (stderr, "Erreur d'inistialisation SDL : %s\n", SDL_GetError()); + + if (TTF_Init ()) + fprintf (stderr, "Erreur d'inistialisation SDL_ttf : %s\n", SDL_GetError()); SDL_Surface* window = SDL_SetVideoMode (DWIDTH, DHEIGHT, SDL_GetVideoInfo()->vfmt->BitsPerPixel, SDL_HWSURFACE | SDL_RESIZABLE | SDL_DOUBLEBUF); - SDL_FillRect (window, NULL, SDL_MapRGB(window->format, 0, 0, 0)); - SDL_Flip (window); 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; @@ -29,6 +38,8 @@ SDL_Surface* resize_window (SDL_Surface* window, SDL_Event* event) window = SDL_SetVideoMode(w, h, SDL_GetVideoInfo()->vfmt->BitsPerPixel, SDL_HWSURFACE | SDL_RESIZABLE | SDL_DOUBLEBUF); else window = SDL_SetVideoMode (DWIDTH, DHEIGHT, SDL_GetVideoInfo()->vfmt->BitsPerPixel, SDL_HWSURFACE | SDL_RESIZABLE | SDL_DOUBLEBUF); + SDL_FillRect (window, NULL, param->background); + SDL_Flip (window); return window; } @@ -40,7 +51,7 @@ SDL_Surface* fullscreen_window (SDL_Surface* window) } else { - SDL_Rect** modes = SDL_ListModes(window->format, SDL_HWSURFACE | SDL_DOUBLEBUF| SDL_FULLSCREEN); + SDL_Rect** modes = SDL_ListModes(window->format, SDL_HWSURFACE | SDL_FULLSCREEN | SDL_DOUBLEBUF); if(modes == (SDL_Rect **)0) { printf("No modes available!\n"); @@ -61,5 +72,13 @@ SDL_Surface* fullscreen_window (SDL_Surface* window) window = SDL_SetVideoMode(modes[0]->w, modes[0]->h, SDL_GetVideoInfo()->vfmt->BitsPerPixel, SDL_HWSURFACE | SDL_FULLSCREEN | SDL_DOUBLEBUF); } } + SDL_FillRect (window, NULL, param->background); + SDL_Flip (window); return window; } + +void reset_window (SDL_Surface* window) +{ + SDL_FillRect (window, NULL, param->background); + SDL_Flip (window); +} diff --git a/src/window.h b/src/window.h index 4e51d7a..26cb53f 100644 --- a/src/window.h +++ b/src/window.h @@ -5,8 +5,12 @@ 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); + #endif /* _WINDOW_H_ */