2021-12-22 02:17:16 +01:00
/*!\file window.c
2021-12-22 01:57:34 +01:00
* \ author Farès BELHADJ , amsi @ up8 . edu
2021-12-31 15:07:16 +01:00
* \ student Anri KENNEL , anri . kennel @ etud . univ - paris8 . fr
2021-12-22 01:57:34 +01:00
* \ date November 16 , 2021.
*/
# include <assert.h>
2022-01-02 00:25:00 +01:00
# include <time.h>
2021-12-31 15:07:16 +01:00
/* Inclusion des entêtes de fonctions de gestion de primitives simples
2021-12-22 01:57:34 +01:00
* de dessin . La lettre p signifie aussi bien primitive que
* pédagogique . */
# include <GL4D/gl4dp.h>
2021-12-31 15:07:16 +01:00
/* Inclure la bibliothèque de rendu du cours */
2021-12-22 01:57:34 +01:00
# include "rasterize.h"
2021-12-31 15:07:16 +01:00
/* Inclusion des entêtes de fonctions de création et de gestion de
2021-12-22 01:57:34 +01:00
* fenêtres système ouvrant un contexte favorable à GL4dummies . Cette
* partie est dépendante de la bibliothèque SDL2 */
# include <GL4D/gl4duw_SDL2.h>
2021-12-31 15:07:16 +01:00
/* Fonctions locales (static) */
2021-12-22 01:57:34 +01:00
static void init ( void ) ;
2021-12-31 10:11:59 +01:00
static void idle ( void ) ;
2021-12-22 01:57:34 +01:00
static void draw ( void ) ;
2021-12-31 10:11:59 +01:00
static void keyu ( int keycode ) ;
static void keyd ( int keycode ) ;
2021-12-22 01:57:34 +01:00
static void sortie ( void ) ;
2021-12-31 15:07:16 +01:00
/*!\brief Surface représentant un cube */
2021-12-22 01:57:34 +01:00
static surface_t * _cube = NULL ;
2022-01-02 15:13:24 +01:00
static surface_t * _cubeBois = NULL ;
2021-12-31 15:27:23 +01:00
static float _cubeSize = 4.f ;
2021-12-22 01:57:34 +01:00
2022-01-01 22:53:11 +01:00
/*!\brief Surface représentant une sphère */
static surface_t * _sphere = NULL ;
2022-01-02 02:18:23 +01:00
/*!\brief Variable d'état pour activer/désactiver la synchronisation verticale */
2021-12-31 10:26:31 +01:00
static int _use_vsync = 1 ;
2021-12-22 01:57:34 +01:00
2022-01-02 02:18:23 +01:00
/*!\brief Variable d'état pour activer/désactiver le debug */
2022-01-01 21:21:15 +01:00
static int _debug = 0 ;
2022-01-02 17:11:12 +01:00
/*!\brief Grille de positions où il y aura des cubes (valeur reservée = défini automatiquement par le programme)
2022-01-01 21:18:23 +01:00
* 0 - > Vide
* 1 - > Mur
2022-01-02 17:11:12 +01:00
* 2 ( valeur reservée ) - > Joueur A
* 3 ( valeur reservée ) - > Joueur B
2022-01-02 16:32:43 +01:00
* 4 - > Bloc destructible
* 5 - > Mur extérieur
2022-01-02 17:11:12 +01:00
* 6 ( valeur reservée ) - > Bombe A
* 7 ( valeur reservée ) - > Bombe B */
2022-01-02 02:20:09 +01:00
static int * _plateau = NULL ;
2022-01-02 02:18:23 +01:00
/*!\brief Largeur/Nombre de lignes de la grille */
2022-01-02 18:01:31 +01:00
static int _plateauW ;
2022-01-02 02:18:23 +01:00
/*!\brief Hauteur/Nombre de colonnes de la grille */
2022-01-02 18:01:31 +01:00
static int _plateauH ;
2021-12-31 10:11:59 +01:00
/* Définition d'un personnage */
typedef struct perso_t {
2022-01-02 02:18:23 +01:00
float x , y , z ; /* Coordonées spatiale */
2022-01-02 16:48:59 +01:00
int position ; /* Position dans la grille.
* Permet d ' é viter aux joueurs
* de se rentrer dedans */
2022-01-02 17:23:46 +01:00
double bombe ; /* si une bombe est placé par le joueur,
2022-01-02 16:48:59 +01:00
* temps é coulé depuis sa pose */
2022-01-02 17:11:12 +01:00
int bombePos ; /* Position de la bombe */
2021-12-31 10:11:59 +01:00
} perso_t ;
2021-12-31 10:44:28 +01:00
/* Définition de nos deux joueurs */
2022-01-02 17:11:12 +01:00
perso_t _joueurA = { 0.f , 0.f , 0.f , - 1 , 0 , - 1 } ; // à droite
perso_t _joueurB = { 0.f , 0.f , 6.f , - 1 , 0 , - 1 } ; // à gauche
2021-12-31 10:11:59 +01:00
2021-12-31 15:07:16 +01:00
/* Clavier virtuel */
2021-12-31 10:11:59 +01:00
enum {
2022-01-02 02:28:03 +01:00
/* Joueur A */
2021-12-31 10:44:28 +01:00
VK_RIGHT = 0 ,
VK_UP ,
VK_LEFT ,
VK_DOWN ,
2022-01-02 03:14:43 +01:00
VK_RETURN ,
2021-12-31 10:44:28 +01:00
2022-01-02 02:28:03 +01:00
/* Joueur B */
2021-12-31 10:44:28 +01:00
VK_d ,
VK_z ,
VK_q ,
VK_s ,
2022-01-02 03:14:43 +01:00
VK_SPACE ,
2021-12-31 10:44:28 +01:00
2021-12-31 15:07:16 +01:00
/* Toujours à la fin */
2021-12-31 10:44:28 +01:00
VK_SIZEOF
2021-12-31 10:11:59 +01:00
} ;
2021-12-31 10:44:28 +01:00
int _vkeyboard [ VK_SIZEOF ] = { 0 , 0 , 0 , 0 , 0 , 0 , 0 , 0 } ;
2021-12-22 01:57:34 +01:00
2021-12-31 15:07:16 +01:00
/*!\brief Paramètre l'application et lance la boucle infinie. */
2021-12-22 01:57:34 +01:00
int main ( int argc , char * * argv ) {
2021-12-31 15:07:16 +01:00
/* Tentative de création d'une fenêtre pour GL4Dummies */
2021-12-22 02:17:16 +01:00
if ( ! gl4duwCreateWindow ( argc , argv , /* args du programme */
2021-12-27 14:12:36 +01:00
" Bomberman ⋅ A. KENNEL L2-A " , /* titre */
2021-12-22 02:17:16 +01:00
10 , 10 , 800 , 600 , /* x, y, largeur, heuteur */
GL4DW_SHOWN ) /* état visible */ ) {
2021-12-31 15:07:16 +01:00
/* Ici si échec de la création souvent lié à un problème d'absence
2021-12-22 02:17:16 +01:00
* de contexte graphique ou d ' impossibilité d ' ouverture d ' un
* contexte OpenGL ( au moins 3.2 ) */
return 1 ;
}
init ( ) ;
2021-12-31 10:11:59 +01:00
2021-12-31 15:07:16 +01:00
/* Mets en place la fonction d'interception clavier touche pressée */
2021-12-31 10:11:59 +01:00
gl4duwKeyDownFunc ( keyd ) ;
2021-12-31 15:07:16 +01:00
/* Mets en place la fonction d'interception clavier touche relachée */
2021-12-31 10:11:59 +01:00
gl4duwKeyUpFunc ( keyu ) ;
2021-12-31 15:07:16 +01:00
/* Mets en place la fonction idle (simulation, au sens physique du terme) */
2021-12-31 10:11:59 +01:00
gl4duwIdleFunc ( idle ) ;
2021-12-31 15:07:16 +01:00
/* Mets en place la fonction de display */
2021-12-22 02:17:16 +01:00
gl4duwDisplayFunc ( draw ) ;
2021-12-31 10:11:59 +01:00
2021-12-31 15:07:16 +01:00
/* Boucle infinie pour éviter que le programme ne s'arrête et ferme
2021-12-22 02:17:16 +01:00
* la fenêtre immédiatement */
gl4duwMainLoop ( ) ;
return 0 ;
2021-12-22 01:57:34 +01:00
}
2021-12-31 10:22:22 +01:00
/*!\brief init de nos données, spécialement le plateau */
2021-12-22 01:57:34 +01:00
void init ( void ) {
2021-12-31 15:07:16 +01:00
/* Création d'un screen GL4Dummies (texture dans laquelle nous
* pouvons dessiner ) aux dimensions de la fenêtre . IMPORTANT de
2021-12-22 02:17:16 +01:00
* créer le screen avant d ' utiliser les fonctions liées au
* textures */
gl4dpInitScreen ( ) ;
2021-12-31 10:11:59 +01:00
2021-12-31 15:07:16 +01:00
/* Création du cube */
2022-01-02 15:13:24 +01:00
_cube = mk_cube ( ) ; /* ça fait 2x6 triangles */
_cubeBois = mk_cube ( ) ; /* ça fait 2x6 triangles */
_sphere = mk_sphere ( 12 , 12 ) ; /* ça fait 12x12 triangles */
2021-12-31 10:11:59 +01:00
2021-12-31 15:07:16 +01:00
/* Rajoute la texture */
2022-01-02 15:13:24 +01:00
GLuint tex = get_texture_from_BMP ( " images/tex.bmp " ) ;
set_texture_id ( _cube , tex ) ;
set_texture_id ( _sphere , tex ) ;
GLuint bois = get_texture_from_BMP ( " images/bois.bmp " ) ;
set_texture_id ( _cubeBois , bois ) ;
2021-12-31 10:11:59 +01:00
2021-12-31 10:44:28 +01:00
/* Affichage des textures */
enable_surface_option ( _cube , SO_USE_TEXTURE ) ;
2022-01-02 15:13:24 +01:00
enable_surface_option ( _cubeBois , SO_USE_TEXTURE ) ;
2022-01-01 22:53:11 +01:00
enable_surface_option ( _sphere , SO_USE_TEXTURE ) ;
2021-12-31 10:44:28 +01:00
/* Affichage des ombres */
enable_surface_option ( _cube , SO_USE_LIGHTING ) ;
2022-01-02 15:13:24 +01:00
enable_surface_option ( _cubeBois , SO_USE_LIGHTING ) ;
2022-01-01 22:53:11 +01:00
enable_surface_option ( _sphere , SO_USE_LIGHTING ) ;
2021-12-31 10:44:28 +01:00
2021-12-31 15:07:16 +01:00
/* Si _use_vsync != 0, on active la synchronisation verticale */
2021-12-31 11:20:30 +01:00
SDL_GL_SetSwapInterval ( _use_vsync ) ;
2021-12-31 10:11:59 +01:00
2022-01-02 02:20:09 +01:00
/* Génération du plateau
* et placement des joueurs */
2022-01-02 00:25:00 +01:00
srand ( time ( NULL ) ) ;
2022-01-02 02:20:09 +01:00
/* Génération des dimensions du plateau */
2022-01-02 18:01:31 +01:00
_plateauW = 15 + ( rand ( ) % 10 ) ;
_plateauH = _plateauW ;
2022-01-02 00:25:00 +01:00
2022-01-02 02:20:09 +01:00
/* Placement des joueurs */
2022-01-02 02:28:03 +01:00
/* Joueur A */
2022-01-02 18:01:31 +01:00
int caseA = ( _plateauW * _plateauH ) - ( _plateauW * 2 ) - 3 ; // MAX - Wx2 - 3
_joueurA . x = ( caseA / _plateauH ) * 1.5 ;
_joueurA . z = ( caseA / _plateauW ) * 1.5 ;
2022-01-02 02:28:03 +01:00
/* Joueur B */
2022-01-02 18:01:31 +01:00
int caseB = ( _plateauW * 2 ) + 3 ; // Wx2 + 3
_joueurB . x = - ( caseB / _plateauH ) * 12 ;
_joueurB . z = - ( caseB / _plateauW ) * 12 ;
2022-01-02 02:20:09 +01:00
2022-01-02 18:01:31 +01:00
if ( ( _plateau = malloc ( ( _plateauW * _plateauH ) * sizeof ( int ) ) ) = = NULL ) {
2022-01-02 00:25:00 +01:00
printf ( " Impossible d'allouer de la mémoire supplémentaire pour générer le plateau. \n " ) ;
sortie ( ) ;
exit ( 1 ) ;
}
2022-01-02 02:20:09 +01:00
/* Génération du plateau */
2022-01-02 18:01:31 +01:00
for ( int i = 0 ; i < _plateauH ; i + + )
for ( int j = 0 ; j < _plateauW ; j + + ) {
int _case = i * _plateauH + j ;
2022-01-02 03:04:16 +01:00
if ( i = = 0 ) { // mur en haut
2022-01-02 16:32:43 +01:00
_plateau [ _case ] = 5 ;
2022-01-02 00:25:00 +01:00
continue ;
}
2022-01-02 18:01:31 +01:00
if ( i = = ( _plateauH - 1 ) ) { // mur en bas
2022-01-02 16:32:43 +01:00
_plateau [ _case ] = 5 ;
2022-01-02 00:25:00 +01:00
continue ;
}
2022-01-02 03:04:16 +01:00
if ( j = = 0 ) { // mur a gauche
2022-01-02 16:32:43 +01:00
_plateau [ _case ] = 5 ;
2022-01-02 00:25:00 +01:00
continue ;
}
2022-01-02 18:01:31 +01:00
if ( j = = ( _plateauW - 1 ) ) { // mur a droite
2022-01-02 16:32:43 +01:00
_plateau [ _case ] = 5 ;
2022-01-02 00:25:00 +01:00
continue ;
}
2022-01-02 03:04:16 +01:00
if ( ( j % 2 ) = = 0 & & ( i % 2 ) = = 0 ) { // mur à l'intérieur
2022-01-02 02:48:42 +01:00
_plateau [ _case ] = 1 ;
2022-01-02 00:25:00 +01:00
continue ;
}
2022-01-02 02:48:42 +01:00
_plateau [ _case ] = 0 ;
2022-01-02 00:25:00 +01:00
}
2022-01-02 02:48:42 +01:00
/* On ajoute les blocs qui sont déstructibles par les joueurs */
2022-01-02 18:01:31 +01:00
for ( int i = 0 ; i < _plateauH ; i + + )
for ( int j = 0 ; j < _plateauW ; j + + ) {
int _case = i * _plateauH + j ;
2022-01-02 02:48:42 +01:00
if ( _plateau [ _case ] = = 0 )
2022-01-02 03:14:43 +01:00
if ( rand ( ) % 3 = = 0 ) // 1 chance sur 3
2022-01-02 02:48:42 +01:00
_plateau [ _case ] = 4 ;
}
2022-01-02 01:42:45 +01:00
/* On s'assure que au moins une cases autours du joueurs sont libre
* ç a donne ç a :
2022-01-02 02:48:42 +01:00
* A B C
* D x E
* F G H
* avec A B C D E F G H des positions
2022-01-02 03:04:16 +01:00
* et x le joueur Attention au bordures !
* On les fait spawn loin des bordures
* pour é viter tout problèmes . */
2022-01-02 18:01:31 +01:00
int caseJoueurA = round ( ( _joueurA . z + _cubeSize * _plateauH / 2 ) / _cubeSize ) * _plateauH + round ( ( _joueurA . x + _cubeSize * _plateauW / 2 ) / _cubeSize ) ;
int caseJoueurB = round ( ( _joueurB . z + _cubeSize * _plateauH / 2 ) / _cubeSize ) * _plateauH + round ( ( _joueurB . x + _cubeSize * _plateauW / 2 ) / _cubeSize ) ;
2022-01-02 03:04:16 +01:00
/* Joueur A */
_plateau [ caseJoueurA ] = 2 ; // x (facultatif)
2022-01-02 18:01:31 +01:00
_plateau [ caseJoueurA - _plateauW - 1 ] = 0 ; // A
_plateau [ caseJoueurA - _plateauW ] = 0 ; // B
_plateau [ caseJoueurA - _plateauW + 1 ] = 0 ; // C
2022-01-02 03:04:16 +01:00
_plateau [ caseJoueurA - 1 ] = 0 ; // D
_plateau [ caseJoueurA + 1 ] = 0 ; // E
2022-01-02 18:01:31 +01:00
_plateau [ caseJoueurA + _plateauW - 1 ] = 0 ; // F
_plateau [ caseJoueurA + _plateauW ] = 0 ; // G
_plateau [ caseJoueurA + _plateauW + 1 ] = 0 ; // H
2022-01-02 03:04:16 +01:00
/* Joueur B */
_plateau [ caseJoueurB ] = 3 ; // x (facultatif)
2022-01-02 18:01:31 +01:00
_plateau [ caseJoueurB - _plateauW - 1 ] = 0 ; // A
_plateau [ caseJoueurB - _plateauW ] = 0 ; // B
_plateau [ caseJoueurB - _plateauW + 1 ] = 0 ; // C
2022-01-02 03:04:16 +01:00
_plateau [ caseJoueurB - 1 ] = 0 ; // D
_plateau [ caseJoueurB + 1 ] = 0 ; // E
2022-01-02 18:01:31 +01:00
_plateau [ caseJoueurB + _plateauW - 1 ] = 0 ; // F
_plateau [ caseJoueurB + _plateauW ] = 0 ; // G
_plateau [ caseJoueurB + _plateauW + 1 ] = 0 ; // H
2022-01-02 01:42:45 +01:00
2021-12-31 15:07:16 +01:00
/* Mets en place la fonction à appeler en cas de sortie */
2021-12-22 02:17:16 +01:00
atexit ( sortie ) ;
2021-12-22 01:57:34 +01:00
}
2021-12-31 15:07:16 +01:00
/*!\brief Fonction appellée à chaque idle (entre chaque frame) */
2021-12-31 10:11:59 +01:00
void idle ( void ) {
/* on récupère le delta-temps */
static double t0 = 0.0 ; // le temps à la frame précédente
double t , dt ;
t = gl4dGetElapsedTime ( ) ;
dt = ( t - t0 ) / 1000.0 ; // diviser par mille pour avoir des secondes
2021-12-31 15:07:16 +01:00
/* pour le frame d'après, mets à-jour t0 */
2021-12-31 10:11:59 +01:00
t0 = t ;
2022-01-02 13:22:20 +01:00
float vitesse = 9.f ; // vitesse des joueurs
2022-01-01 20:54:59 +01:00
/* Calcul du décalage */
2022-01-02 15:29:12 +01:00
/* float decalageAutorisee = .2f; // décalage autorisé, modifier cette valeur si nécessaire
2022-01-01 20:54:59 +01:00
float decalageGB = .0f + decalageAutorisee ; // décalage pour la gauche et le bas
2022-01-02 15:29:12 +01:00
float decalageDH = 1.f - decalageAutorisee ; // décalage pour la droite et le haut */
2022-01-01 20:54:59 +01:00
2022-01-02 02:28:03 +01:00
/* Mouvements du Joueur A */
2021-12-31 17:22:04 +01:00
/* Coordonées x, z */
2022-01-02 18:01:31 +01:00
float zA = ( _joueurA . z + _cubeSize * _plateauH / 2 ) / _cubeSize ; // ligne - hauteur
float xA = ( _joueurA . x + _cubeSize * _plateauW / 2 ) / _cubeSize ; // colonne - longueur
2021-12-31 17:22:04 +01:00
/* Coordonnées joueur A */
2022-01-02 18:01:31 +01:00
int posJoueurA = round ( zA ) * _plateauH + round ( xA ) ;
int posDroiteA = round ( zA ) * _plateauH + ceil ( xA ) ;
int posHautA = floor ( zA ) * _plateauH + round ( xA ) ;
int posGaucheA = round ( zA ) * _plateauH + floor ( xA ) ;
int posBasA = ceil ( zA ) * _plateauH + round ( xA ) ;
2022-01-01 20:54:59 +01:00
/* Décalage pour éviter bug de collisions */
2022-01-02 15:29:12 +01:00
/* float decalageLargeurA = zA - floor(zA);
float decalageLongueurA = xA - floor ( xA ) ; */
2021-12-31 17:22:04 +01:00
2022-01-02 13:22:20 +01:00
/* Déplacement
* Pour la vérification du " si mur "
* Dans ce cas de figure :
* A B C
* D x E
* F G H
* Pour aller à droite on regarde si C et H ne sont pas des murs
2022-01-02 16:32:43 +01:00
* On part de la posdonnées de droite car posDroite = E . */
2021-12-31 10:11:59 +01:00
if ( _vkeyboard [ VK_RIGHT ] )
2022-01-02 13:22:20 +01:00
/* Collision à droite du joueur */
2022-01-02 17:11:12 +01:00
if ( _plateau [ posDroiteA ] = = 0 | | _plateau [ posDroiteA ] = = 2 | | _plateau [ posDroiteA ] = = 6 | | _plateau [ posDroiteA ] = = 7 ) // si case vide ou joueur ou bombe
2022-01-02 15:19:39 +01:00
/* if(decalageLargeurA < decalageGB || decalageLargeurA > decalageDH) */ _joueurA . x + = vitesse * dt ; // on s'assure d'être aligné
2022-01-02 13:22:20 +01:00
2021-12-31 15:27:23 +01:00
if ( _vkeyboard [ VK_UP ] )
2022-01-02 13:22:20 +01:00
/* Collision en haut du joueur */
2022-01-02 17:11:12 +01:00
if ( _plateau [ posHautA ] = = 0 | | _plateau [ posHautA ] = = 2 | | _plateau [ posHautA ] = = 6 | | _plateau [ posHautA ] = = 7 ) // si case vide ou joueur ou bombe
2022-01-02 15:19:39 +01:00
/* if(decalageLongueurA < decalageGB || decalageLongueurA > decalageDH) */ _joueurA . z - = vitesse * dt ; // on s'assure d'être aligné
2022-01-02 13:22:20 +01:00
2021-12-31 15:27:23 +01:00
if ( _vkeyboard [ VK_LEFT ] )
2022-01-02 13:22:20 +01:00
/* Collision à gauche du joueur */
2022-01-02 17:11:12 +01:00
if ( _plateau [ posGaucheA ] = = 0 | | _plateau [ posGaucheA ] = = 2 | | _plateau [ posGaucheA ] = = 6 | | _plateau [ posGaucheA ] = = 7 ) // si case vide ou joueur ou bombe
2022-01-02 15:19:39 +01:00
/* if(decalageLargeurA < decalageGB || decalageLargeurA > decalageDH) */ _joueurA . x - = vitesse * dt ; // on s'assure d'être aligné
2022-01-02 13:22:20 +01:00
2021-12-31 15:27:23 +01:00
if ( _vkeyboard [ VK_DOWN ] )
2022-01-02 13:22:20 +01:00
/* Collision en bas du joueur */
2022-01-02 17:11:12 +01:00
if ( _plateau [ posBasA ] = = 0 | | _plateau [ posBasA ] = = 2 | | _plateau [ posBasA ] = = 6 | | _plateau [ posBasA ] = = 7 ) // si case vide ou joueur ou bombe
2022-01-02 15:19:39 +01:00
/* if(decalageLongueurA < decalageGB || decalageLongueurA > decalageDH) */ _joueurA . z + = vitesse * dt ; // on s'assure d'être aligné
2022-01-02 15:16:51 +01:00
2022-01-02 03:14:43 +01:00
if ( _vkeyboard [ VK_RETURN ] ) {
2022-01-02 13:22:20 +01:00
_vkeyboard [ VK_RETURN ] = 0 ; // on évite de spam la pose de bombe
2022-01-02 16:48:59 +01:00
if ( _joueurA . bombe = = 0 ) {
2022-01-02 17:23:46 +01:00
_joueurA . bombe = t + 1 ;
2022-01-02 17:11:12 +01:00
_joueurA . bombePos = posJoueurA ;
2022-01-02 16:48:59 +01:00
if ( _debug ) printf ( " Joueur A pose une bombe! \n " ) ;
_plateau [ posJoueurA ] = 6 ;
}
2022-01-02 03:14:43 +01:00
}
2022-01-01 21:18:23 +01:00
2022-01-02 18:01:31 +01:00
if ( ( int ) ( t - ( _joueurA . bombe - 1 ) ) / 1000 > = 3 & & _joueurA . bombe ! = 0 ) { // quand la bombe doit explosé
for ( int i = 0 ; i < = 2 ; i + + ) { // on supprime les caisses aux alentours
/* Vérification mort d'un joueur */
int mort = 0 ;
if ( _plateau [ _joueurA . bombePos - _plateauW - i ] = = 2 | | _plateau [ _joueurA . bombePos - _plateauW - i ] = = 3 ) _plateau [ _joueurA . bombePos - _plateauW - i ] = 0 ;
if ( _plateau [ _joueurA . bombePos - _plateauW + i ] = = 2 | | _plateau [ _joueurA . bombePos - _plateauW + i ] = = 3 ) _plateau [ _joueurA . bombePos - _plateauW + i ] = 0 ;
if ( _plateau [ _joueurA . bombePos - i ] = = 2 | | _plateau [ _joueurA . bombePos - i ] = = 3 ) _plateau [ _joueurA . bombePos - i ] = 0 ;
if ( _plateau [ _joueurA . bombePos + i ] = = 2 | | _plateau [ _joueurA . bombePos + i ] = = 3 ) _plateau [ _joueurA . bombePos + i ] = 0 ;
if ( _plateau [ _joueurA . bombePos + _plateauW - i ] = = 2 | | _plateau [ _joueurA . bombePos + _plateauW - i ] = = 3 ) _plateau [ _joueurA . bombePos + _plateauW - i ] = 0 ;
if ( _plateau [ _joueurA . bombePos + _plateauW + i ] = = 2 | | _plateau [ _joueurA . bombePos + _plateauW + i ] = = 3 ) _plateau [ _joueurA . bombePos + _plateauW + i ] = 0 ;
/* On vérifie que les 2 joueurs sont bien dans la map,
* s ' il en manque un c ' est qu ' il est probablement
* à la position de la bombe */
int trouveA = 0 ;
int trouveB = 0 ;
for ( int j = _plateauW ; j < _plateauH * _plateauW ; j + + ) {
if ( _plateau [ j ] = = 2 ) trouveA = 1 ;
if ( _plateau [ j ] = = 3 ) trouveB = 1 ;
}
if ( trouveA = = 0 ) mort = 2 ;
if ( trouveB = = 0 ) mort = 3 ;
if ( trouveA = = 0 & & trouveB = = 0 ) mort = 4 ;
if ( mort ! = 0 ) {
if ( mort = = 4 ) printf ( " TERMINÉ ! TOUT LE MONDE A PERDU ! \n " ) ;
else printf ( " TERMINÉ ! JOUEUR %d A PERDU ! \n " , mort ) ;
sortie ( ) ;
exit ( 0 ) ;
}
/* Suppression des blocs touchés */
if ( _plateau [ _joueurA . bombePos - _plateauW - i ] = = 4 ) _plateau [ _joueurA . bombePos - _plateauW - i ] = 0 ;
if ( _plateau [ _joueurA . bombePos - _plateauW + i ] = = 4 ) _plateau [ _joueurA . bombePos - _plateauW + i ] = 0 ;
if ( _plateau [ _joueurA . bombePos - i ] = = 4 ) _plateau [ _joueurA . bombePos - i ] = 0 ;
if ( _plateau [ _joueurA . bombePos + i ] = = 4 ) _plateau [ _joueurA . bombePos + i ] = 0 ;
if ( _plateau [ _joueurA . bombePos + _plateauW - i ] = = 4 ) _plateau [ _joueurA . bombePos + _plateauW - i ] = 0 ;
if ( _plateau [ _joueurA . bombePos + _plateauW + i ] = = 4 ) _plateau [ _joueurA . bombePos + _plateauW + i ] = 0 ;
}
2022-01-02 17:11:12 +01:00
_joueurA . bombe = 0 ; // remet le timer à 0
_plateau [ _joueurA . bombePos ] = 0 ; // vide le plateau de la bombe
_joueurA . bombePos = - 1 ; // supprime l'ancienne location de la bombe
}
2022-01-01 21:18:23 +01:00
/* Affichage Debug */
2022-01-01 21:21:15 +01:00
if ( _debug ) {
2022-01-02 02:28:03 +01:00
printf ( " \n ========== Joueur A ========== \n " ) ;
2022-01-02 16:48:59 +01:00
printf ( " li = %d, col = %d, idx = %d \n " , ( int ) ( zA + .5f ) , ( int ) ( xA + .5f ) , _joueurA . position ) ; // round avec cast int
2022-01-01 21:36:20 +01:00
printf ( " zA=%f xA=%f \n " , zA , xA ) ;
2022-01-02 16:32:43 +01:00
printf ( " d=%d h=%d g=%d b=%d \n " , posDroiteA , posHautA , posGaucheA , posBasA ) ;
2022-01-01 21:21:15 +01:00
}
2021-12-31 10:44:28 +01:00
2022-01-01 21:18:23 +01:00
/* Anti-collision entre joueurs */
2022-01-02 17:11:12 +01:00
if ( _joueurA . position ! = posJoueurA & & _plateau [ posJoueurA ] ! = 6 & & _plateau [ _joueurA . position ] ! = 6 & & _plateau [ posJoueurA ] ! = 7 & & _plateau [ _joueurA . position ] ! = 7 ) { // si position différente et pas une bombe
2022-01-02 16:34:54 +01:00
_plateau [ _joueurA . position ] = 0 ; // on met l'ancienne position a un bloc vide
_plateau [ posJoueurA ] = 2 ; // on met a jour le plateau
2022-01-01 21:18:23 +01:00
}
2022-01-02 18:01:31 +01:00
_joueurA . position = posJoueurA ; // on change la position dans perso_t
2022-01-01 21:18:23 +01:00
2022-01-02 02:28:03 +01:00
/* Mouvements du Joueur B */
2021-12-31 17:22:04 +01:00
/* Coordonées x, z */
2022-01-02 18:01:31 +01:00
float zB = ( float ) ( ( _joueurB . z + _cubeSize * _plateauH / 2 ) / _cubeSize ) ; // ligne - hauteur
float xB = ( float ) ( ( _joueurB . x + _cubeSize * _plateauW / 2 ) / _cubeSize ) ; // colonne - longueur
2021-12-31 17:22:04 +01:00
2022-01-01 20:54:59 +01:00
/* Coordonnées joueur A */
2022-01-02 18:01:31 +01:00
int posJoueurB = round ( zB ) * _plateauH + round ( xB ) ;
int posDroiteB = round ( zB ) * _plateauH + ceil ( xB ) ;
int posHautB = floor ( zB ) * _plateauH + round ( xB ) ;
int posGaucheB = round ( zB ) * _plateauH + floor ( xB ) ;
int posBasB = ceil ( zB ) * _plateauH + round ( xB ) ;
2022-01-01 20:54:59 +01:00
/* Décalage pour éviter bug de collisions */
2022-01-02 15:29:12 +01:00
/* float decalageLargeurB = zB - floor(zB);
float decalageLongueurB = xB - floor ( xB ) ; */
2021-12-31 17:22:04 +01:00
2022-01-01 21:18:23 +01:00
/* Déplacement */
2021-12-31 10:44:28 +01:00
if ( _vkeyboard [ VK_d ] )
2022-01-02 13:22:20 +01:00
/* Collision à droite du joueur */
2022-01-02 17:11:12 +01:00
if ( _plateau [ posDroiteB ] = = 0 | | _plateau [ posDroiteB ] = = 3 | | _plateau [ posDroiteB ] = = 6 | | _plateau [ posDroiteB ] = = 7 ) // si case vide ou joueur ou bombe
2022-01-02 15:19:39 +01:00
/* if(decalageLargeurB < decalageGB || decalageLargeurB > decalageDH) */ _joueurB . x + = vitesse * dt ; // on s'assure d'être aligné
2022-01-02 13:22:20 +01:00
2022-01-02 15:31:57 +01:00
if ( _vkeyboard [ VK_z ] )
2022-01-02 13:22:20 +01:00
/* Collision en haut du joueur */
2022-01-02 17:11:12 +01:00
if ( _plateau [ posHautB ] = = 0 | | _plateau [ posHautB ] = = 3 | | _plateau [ posHautB ] = = 6 | | _plateau [ posHautB ] = = 7 ) // si case vide ou joueur ou bombe
2022-01-02 15:19:39 +01:00
/* if(decalageLongueurB < decalageGB || decalageLongueurB > decalageDH) */ _joueurB . z - = vitesse * dt ; // on s'assure d'être aligné
2022-01-02 13:22:20 +01:00
2021-12-31 15:27:23 +01:00
if ( _vkeyboard [ VK_q ] )
2022-01-02 13:22:20 +01:00
/* Collision à gauche du joueur */
2022-01-02 17:11:12 +01:00
if ( _plateau [ posGaucheB ] = = 0 | | _plateau [ posGaucheB ] = = 3 | | _plateau [ posGaucheB ] = = 6 | | _plateau [ posGaucheB ] = = 7 ) // si case vide ou joueur ou bombe
2022-01-02 15:19:39 +01:00
/* if(decalageLargeurB < decalageGB || decalageLargeurB > decalageDH) */ _joueurB . x - = vitesse * dt ; // on s'assure d'être aligné
2022-01-02 13:22:20 +01:00
2021-12-31 15:27:23 +01:00
if ( _vkeyboard [ VK_s ] )
2022-01-02 13:22:20 +01:00
/* Collision en bas du joueur */
2022-01-02 17:11:12 +01:00
if ( _plateau [ posBasB ] = = 0 | | _plateau [ posBasB ] = = 3 | | _plateau [ posBasB ] = = 6 | | _plateau [ posBasB ] = = 7 ) // si case vide ou joueur ou bombe
2022-01-02 15:19:39 +01:00
/* if(decalageLongueurB < decalageGB || decalageLongueurB > decalageDH) */ _joueurB . z + = vitesse * dt ; // on s'assure d'être aligné
2022-01-02 15:16:51 +01:00
2022-01-02 03:14:43 +01:00
if ( _vkeyboard [ VK_SPACE ] ) {
2022-01-02 13:22:20 +01:00
_vkeyboard [ VK_SPACE ] = 0 ; // on évite de spam la pose de bombe
2022-01-02 16:48:59 +01:00
if ( _joueurB . bombe = = 0 ) {
2022-01-02 17:23:46 +01:00
_joueurB . bombe = t + 1 ;
2022-01-02 17:11:12 +01:00
_joueurB . bombePos = posJoueurB ;
2022-01-02 16:48:59 +01:00
if ( _debug ) printf ( " Joueur B pose une bombe! \n " ) ;
2022-01-02 17:11:12 +01:00
_plateau [ posJoueurB ] = 7 ;
2022-01-02 16:48:59 +01:00
}
2022-01-02 03:14:43 +01:00
}
2022-01-01 21:18:23 +01:00
2022-01-02 18:01:31 +01:00
if ( ( int ) ( t - ( _joueurB . bombe - 1 ) ) / 1000 > = 3 & & _joueurB . bombe ! = 0 ) { // quand la bombe doit explosé
for ( int i = 0 ; i < = 2 ; i + + ) { // on supprime les caisses aux alentours
/* Vérification mort d'un joueur */
int mort = 0 ;
if ( _plateau [ _joueurB . bombePos - _plateauW - i ] = = 2 | | _plateau [ _joueurB . bombePos - _plateauW - i ] = = 3 ) _plateau [ _joueurB . bombePos - _plateauW - i ] = 0 ;
if ( _plateau [ _joueurB . bombePos - _plateauW + i ] = = 2 | | _plateau [ _joueurB . bombePos - _plateauW + i ] = = 3 ) _plateau [ _joueurB . bombePos - _plateauW + i ] = 0 ;
if ( _plateau [ _joueurB . bombePos - i ] = = 2 | | _plateau [ _joueurB . bombePos - i ] = = 3 ) _plateau [ _joueurB . bombePos - i ] = 0 ;
if ( _plateau [ _joueurB . bombePos + i ] = = 2 | | _plateau [ _joueurB . bombePos + i ] = = 3 ) _plateau [ _joueurB . bombePos + i ] = 0 ;
if ( _plateau [ _joueurB . bombePos + _plateauW - i ] = = 2 | | _plateau [ _joueurB . bombePos + _plateauW - i ] = = 3 ) _plateau [ _joueurB . bombePos + _plateauW - i ] = 0 ;
if ( _plateau [ _joueurB . bombePos + _plateauW + i ] = = 2 | | _plateau [ _joueurB . bombePos + _plateauW + i ] = = 3 ) _plateau [ _joueurB . bombePos + _plateauW + i ] = 0 ;
/* On vérifie que les 2 joueurs sont bien dans la map,
* s ' il en manque un c ' est qu ' il est probablement
* à la position de la bombe */
int trouveA = 0 ;
int trouveB = 0 ;
for ( int j = _plateauW ; j < _plateauH * _plateauW ; j + + ) {
if ( _plateau [ j ] = = 2 ) trouveA = 1 ;
if ( _plateau [ j ] = = 3 ) trouveB = 1 ;
}
if ( trouveA = = 0 ) mort = 2 ;
if ( trouveB = = 0 ) mort = 3 ;
if ( trouveA = = 0 & & trouveB = = 0 ) mort = 4 ;
if ( mort ! = 0 ) {
if ( mort = = 4 ) printf ( " TERMINÉ ! TOUT LE MONDE A PERDU ! \n " ) ;
else printf ( " TERMINÉ ! JOUEUR %d A PERDU ! \n " , mort ) ;
sortie ( ) ;
exit ( 0 ) ;
}
/* Suppression des blocs touchés */
if ( _plateau [ _joueurB . bombePos - _plateauW - i ] = = 4 ) _plateau [ _joueurB . bombePos - _plateauW - i ] = 0 ;
if ( _plateau [ _joueurB . bombePos - _plateauW + i ] = = 4 ) _plateau [ _joueurB . bombePos - _plateauW + i ] = 0 ;
if ( _plateau [ _joueurB . bombePos - i ] = = 4 ) _plateau [ _joueurB . bombePos - i ] = 0 ;
if ( _plateau [ _joueurB . bombePos + i ] = = 4 ) _plateau [ _joueurB . bombePos + i ] = 0 ;
if ( _plateau [ _joueurB . bombePos + _plateauW - i ] = = 4 ) _plateau [ _joueurB . bombePos + _plateauW - i ] = 0 ;
if ( _plateau [ _joueurB . bombePos + _plateauW + i ] = = 4 ) _plateau [ _joueurB . bombePos + _plateauW + i ] = 0 ;
}
2022-01-02 17:11:12 +01:00
_joueurB . bombe = 0 ; // remet le timer à 0
_plateau [ _joueurB . bombePos ] = 0 ; // vide le plateau de la bombe
_joueurB . bombePos = - 1 ; // supprime l'ancienne location de la bombe
}
2022-01-01 21:18:23 +01:00
/* Affichage Debug */
2022-01-01 21:21:15 +01:00
if ( _debug ) {
2022-01-02 02:28:03 +01:00
printf ( " ========== Joueur B ========== \n " ) ;
2022-01-02 16:48:59 +01:00
printf ( " li = %d, col = %d, idx = %d \n " , ( int ) ( zB + .5f ) , ( int ) ( xB + .5f ) , _joueurB . position ) ; // round avec cast int
2022-01-02 15:29:12 +01:00
printf ( " zB=%f xB=%f \n " , zB , xB ) ;
2022-01-02 16:32:43 +01:00
printf ( " d=%d h=%d g=%d b=%d \n " , posDroiteB , posHautB , posGaucheB , posBasB ) ;
2022-01-02 02:28:03 +01:00
printf ( " =============================== \n " ) ;
2022-01-01 21:21:15 +01:00
}
2022-01-01 21:18:23 +01:00
/* Anti-collision entre joueurs */
2022-01-02 17:11:12 +01:00
if ( _joueurB . position ! = posJoueurB & & _plateau [ posJoueurB ] ! = 6 & & _plateau [ _joueurB . position ] ! = 6 & & _plateau [ posJoueurB ] ! = 7 & & _plateau [ _joueurB . position ] ! = 7 ) { // si position différente et pas une bombe
2022-01-02 16:34:54 +01:00
_plateau [ _joueurB . position ] = 0 ; // on met l'ancienne position a un bloc vide
_plateau [ posJoueurB ] = 3 ; // on met a jour le plateau
2022-01-01 21:18:23 +01:00
}
2022-01-02 18:01:31 +01:00
_joueurB . position = posJoueurB ; // on change la position dans perso_t
2021-12-31 10:11:59 +01:00
}
2021-12-31 15:07:16 +01:00
/*!\brief Fonction appelée à chaque display. */
2021-12-22 01:57:34 +01:00
void draw ( void ) {
2022-01-02 17:11:12 +01:00
double t = gl4dGetElapsedTime ( ) ;
2022-01-02 16:48:59 +01:00
vec4 couleurMur = { 0.2 , 0.2 , 0.2 , 1 } , /* Gris */
2022-01-02 16:32:43 +01:00
couleurJoueurA = { 0.15 , 0.5 , 0.15 , 1 } , /* Vert */
2022-01-02 16:48:59 +01:00
couleurJoueurB = { 0.2 , 0.2 , 0.7 , 1 } , /* Bleu */
couleurMurExterieur = { 0.1 , 0.1 , 0.1 , 1 } , /* Gris foncé */
couleurBois = { 0.6 , 0.3 , 0 , 1 } , /* Marron */
2022-01-02 17:11:12 +01:00
couleurBombeN = { 0.2 , 0.1 , 0 , 1 } , /* Noir */
couleurBombeO = { 1 , 0.4 , 0.1 , 1 } , /* Orange */
couleurBombeR = { 1 , 0 , 0 , 1 } ; /* Rouge */
2021-12-31 10:11:59 +01:00
2021-12-22 02:17:16 +01:00
float model_view_matrix [ 16 ] , projection_matrix [ 16 ] , nmv [ 16 ] ;
2021-12-31 10:11:59 +01:00
2021-12-31 15:07:16 +01:00
/* Efface l'écran et le buffer de profondeur */
2021-12-22 02:17:16 +01:00
gl4dpClearScreen ( ) ;
clear_depth_map ( ) ;
2021-12-31 10:11:59 +01:00
2021-12-31 15:07:16 +01:00
/* Des macros facilitant le travail avec des matrices et des
2021-12-22 02:17:16 +01:00
* vecteurs se trouvent dans la bibliothèque GL4Dummies , dans le
* fichier gl4dm . h */
2021-12-31 15:07:16 +01:00
/* Charger un frustum dans projection_matrix */
2021-12-22 02:17:16 +01:00
MFRUSTUM ( projection_matrix , - 0.05f , 0.05f , - 0.05f , 0.05f , 0.1f , 1000.0f ) ;
2021-12-31 15:07:16 +01:00
/* Charger la matrice identité dans model-view */
2021-12-22 02:17:16 +01:00
MIDENTITY ( model_view_matrix ) ;
2021-12-31 15:07:16 +01:00
/* On place la caméra en arrière-haut, elle regarde le centre de la scène */
2022-01-02 18:01:31 +01:00
int coefTaille = - 20 + _plateauW * 2.5 ;
2022-01-02 02:18:23 +01:00
lookAt ( model_view_matrix , 0 , 70 + coefTaille /* zoom */ , 30 + coefTaille /* inclinaison */ , 0 , 0 , 0 , 0 , 0 , - 1 ) ;
2021-12-31 10:11:59 +01:00
2021-12-31 15:07:16 +01:00
/* Pour centrer la grille par rapport au monde */
2022-01-02 18:01:31 +01:00
float cX = - _cubeSize * _plateauW / 2.0f ;
float cZ = - _cubeSize * _plateauH / 2.0f ;
2021-12-31 10:11:59 +01:00
2021-12-31 15:07:16 +01:00
/* Pour toutes les cases de la grille, afficher un cube quand il y a
2021-12-31 10:11:59 +01:00
* un 1 dans la grille */
2022-01-02 18:01:31 +01:00
for ( int i = 0 ; i < _plateauW ; + + i )
for ( int j = 0 ; j < _plateauH ; + + j ) {
2022-01-02 02:18:23 +01:00
/* Bloc simple */
2022-01-02 18:01:31 +01:00
if ( _plateau [ i * _plateauW + j ] = = 1 ) {
2022-01-02 16:32:43 +01:00
_cube - > dcolor = couleurMur ;
2021-12-31 10:11:59 +01:00
/* copie model_view_matrix dans nmv */
2022-01-01 22:53:11 +01:00
memcpy ( nmv , model_view_matrix , sizeof ( nmv ) ) ;
2021-12-31 10:11:59 +01:00
2022-01-02 16:32:43 +01:00
/* pour convertir les posdonnées i, j de la grille en x, z du monde */
translate ( nmv , _cubeSize * j + cX , 0.f , _cubeSize * i + cZ ) ;
scale ( nmv , _cubeSize / 2.f , _cubeSize / 2.f , _cubeSize / 2.f ) ;
transform_n_rasterize ( _cube , nmv , projection_matrix ) ;
}
/* Mur exterieur */
2022-01-02 18:01:31 +01:00
if ( _plateau [ i * _plateauW + j ] = = 5 ) {
2022-01-02 16:32:43 +01:00
_cube - > dcolor = couleurMurExterieur ;
/* copie model_view_matrix dans nmv */
memcpy ( nmv , model_view_matrix , sizeof ( nmv ) ) ;
/* pour convertir les posdonnées i, j de la grille en x, z du monde */
translate ( nmv , _cubeSize * j + cX , 0.f , _cubeSize * i + cZ ) ;
scale ( nmv , _cubeSize / 2.f , _cubeSize / 2.f , _cubeSize / 2.f ) ;
2021-12-31 10:11:59 +01:00
transform_n_rasterize ( _cube , nmv , projection_matrix ) ;
}
2022-01-02 02:18:23 +01:00
/* Bloc destructible */
2022-01-02 18:01:31 +01:00
if ( _plateau [ i * _plateauW + j ] = = 4 ) {
2022-01-02 15:13:24 +01:00
_cubeBois - > dcolor = couleurBois ;
2022-01-02 02:18:23 +01:00
/* copie model_view_matrix dans nmv */
memcpy ( nmv , model_view_matrix , sizeof ( nmv ) ) ;
2022-01-02 16:32:43 +01:00
/* pour convertir les posdonnées i, j de la grille en x, z du monde */
translate ( nmv , _cubeSize * j + cX , 0.f , _cubeSize * i + cZ ) ;
2022-01-02 02:48:42 +01:00
scale ( nmv , _cubeSize / 2.6f , _cubeSize / 2.6f , _cubeSize / 2.6f ) ;
2022-01-02 15:13:24 +01:00
transform_n_rasterize ( _cubeBois , nmv , projection_matrix ) ;
2022-01-02 02:18:23 +01:00
}
2022-01-02 17:11:12 +01:00
/* Bombe A */
2022-01-02 18:01:31 +01:00
if ( _plateau [ i * _plateauW + j ] = = 6 ) {
2022-01-02 17:23:46 +01:00
double temps = ( t - ( _joueurA . bombe - 1 ) ) / 1000 ;
_sphere - > dcolor = couleurBombeN ; // avant 1s
if ( ( int ) temps > = 1 ) // avant 2s
2022-01-02 17:11:12 +01:00
_sphere - > dcolor = couleurBombeO ;
2022-01-02 17:23:46 +01:00
if ( ( int ) temps > = 2 ) // avant 3s
2022-01-02 17:11:12 +01:00
_sphere - > dcolor = couleurBombeR ;
/* copie model_view_matrix dans nmv */
memcpy ( nmv , model_view_matrix , sizeof ( nmv ) ) ;
/* pour convertir les posdonnées i, j de la grille en x, z du monde */
translate ( nmv , _cubeSize * j + cX , 0.f , _cubeSize * i + cZ ) ;
2022-01-02 18:06:07 +01:00
double coefExplosion = temps * 1.5 ;
if ( temps < 2.8 ) coefExplosion = 1 ; // effet soudain
scale ( nmv , _cubeSize / 3.f + coefExplosion , _cubeSize / 3.f + coefExplosion , _cubeSize / 3.f + coefExplosion ) ;
2022-01-02 17:11:12 +01:00
transform_n_rasterize ( _sphere , nmv , projection_matrix ) ;
}
/* Bombe B */
2022-01-02 18:01:31 +01:00
if ( _plateau [ i * _plateauW + j ] = = 7 ) {
2022-01-02 17:23:46 +01:00
double temps = ( t - ( _joueurB . bombe - 1 ) ) / 1000 ;
_sphere - > dcolor = couleurBombeN ; // avant 1s
if ( ( int ) temps > = 1 ) // avant 2s
2022-01-02 17:11:12 +01:00
_sphere - > dcolor = couleurBombeO ;
2022-01-02 17:23:46 +01:00
if ( ( int ) temps > = 2 ) // avant 3s
2022-01-02 17:11:12 +01:00
_sphere - > dcolor = couleurBombeR ;
2022-01-02 16:32:43 +01:00
/* copie model_view_matrix dans nmv */
memcpy ( nmv , model_view_matrix , sizeof ( nmv ) ) ;
/* pour convertir les posdonnées i, j de la grille en x, z du monde */
translate ( nmv , _cubeSize * j + cX , 0.f , _cubeSize * i + cZ ) ;
2022-01-02 18:06:07 +01:00
double coefExplosion = temps * 1.5 ;
if ( temps < 2.8 ) coefExplosion = 1 ; // effet soudain
scale ( nmv , _cubeSize / 3.f + coefExplosion , _cubeSize / 3.f + coefExplosion , _cubeSize / 3.f + coefExplosion ) ;
2022-01-02 16:32:43 +01:00
transform_n_rasterize ( _sphere , nmv , projection_matrix ) ;
}
/* Test voir la position des joueurs dans la grille */
2022-01-02 18:01:31 +01:00
/* if(_plateau[i * _plateauW + j] == 2 || _plateau[i * _plateauW + j] == 3) {
2022-01-02 16:32:43 +01:00
vec4 blanc = { 1 , 1 , 1 , 1 } ;
_sphere - > dcolor = blanc ;
memcpy ( nmv , model_view_matrix , sizeof ( nmv ) ) ;
translate ( nmv , _cubeSize * j + cX , 0.f , _cubeSize * i + cZ ) ;
scale ( nmv , _cubeSize / 3.f , _cubeSize / 3.f , _cubeSize / 3.f ) ;
transform_n_rasterize ( _sphere , nmv , projection_matrix ) ;
} */
2022-01-02 02:18:23 +01:00
}
2021-12-31 10:11:59 +01:00
2022-01-02 02:28:03 +01:00
/* Dessine le Joueur A */
_cube - > dcolor = couleurJoueurA ;
_sphere - > dcolor = couleurJoueurA ;
2022-01-01 22:53:11 +01:00
memcpy ( nmv , model_view_matrix , sizeof ( nmv ) ) ;
2022-01-01 23:35:24 +01:00
/* Corps */
2022-01-02 02:28:03 +01:00
translate ( nmv , _joueurA . x , _joueurA . y , _joueurA . z ) ;
2022-01-02 16:32:43 +01:00
scale ( nmv , _cubeSize / 3.f , _cubeSize / 3.f , _cubeSize / 3.f ) ;
2021-12-31 10:44:28 +01:00
transform_n_rasterize ( _cube , nmv , projection_matrix ) ;
2022-01-01 23:35:24 +01:00
/* Tête */
2022-01-02 16:32:43 +01:00
translate ( nmv , 0.f , 2.f , 0.f ) ;
2022-01-01 22:53:11 +01:00
transform_n_rasterize ( _sphere , nmv , projection_matrix ) ;
2021-12-31 10:44:28 +01:00
2022-01-02 02:28:03 +01:00
/* Dessine le Joueur B */
_cube - > dcolor = couleurJoueurB ;
_sphere - > dcolor = couleurJoueurB ;
2022-01-01 22:53:11 +01:00
memcpy ( nmv , model_view_matrix , sizeof ( nmv ) ) ;
2022-01-01 23:35:24 +01:00
/* Corps */
2022-01-02 02:28:03 +01:00
translate ( nmv , _joueurB . x , _joueurB . y , _joueurB . z ) ;
2022-01-02 16:32:43 +01:00
scale ( nmv , _cubeSize / 3.f , _cubeSize / 3.f , _cubeSize / 3.f ) ;
2021-12-22 02:17:16 +01:00
transform_n_rasterize ( _cube , nmv , projection_matrix ) ;
2022-01-01 23:35:24 +01:00
/* Tête */
2022-01-02 16:32:43 +01:00
translate ( nmv , 0.f , 2.f , 0.f ) ;
2022-01-01 22:53:11 +01:00
transform_n_rasterize ( _sphere , nmv , projection_matrix ) ;
2021-12-31 10:11:59 +01:00
2022-01-01 21:00:24 +01:00
/* Déclare que l'on a changé des pixels de l'écran (bas niveau) */
2021-12-22 02:17:16 +01:00
gl4dpScreenHasChanged ( ) ;
2021-12-31 10:11:59 +01:00
2021-12-31 15:07:16 +01:00
/* Fonction permettant de raffraîchir l'ensemble de la fenêtre*/
2021-12-22 02:17:16 +01:00
gl4dpUpdateScreen ( NULL ) ;
2021-12-22 01:57:34 +01:00
}
2021-12-31 15:07:16 +01:00
/*!\brief Intercepte l'événement clavier pour modifier les options (à l'appuie d'une touche). */
2021-12-31 10:11:59 +01:00
void keyd ( int keycode ) {
2021-12-22 02:17:16 +01:00
switch ( keycode ) {
2022-01-02 03:14:43 +01:00
case GL4DK_v : // 'v' utiliser la sync Verticale
2021-12-31 10:26:31 +01:00
_use_vsync = ! _use_vsync ;
if ( _use_vsync )
SDL_GL_SetSwapInterval ( 1 ) ;
2021-12-31 10:11:59 +01:00
else
2021-12-31 10:26:31 +01:00
SDL_GL_SetSwapInterval ( 0 ) ;
2021-12-31 10:11:59 +01:00
break ;
2022-01-02 03:14:43 +01:00
case GL4DK_h : // 'h' afficher ou non les infos de debug
2022-01-01 21:21:15 +01:00
_debug = ! _debug ;
break ;
2022-01-02 02:28:03 +01:00
/* Joueur A */
2022-01-02 03:14:43 +01:00
case GL4DK_RIGHT : // droite
2021-12-31 10:11:59 +01:00
_vkeyboard [ VK_RIGHT ] = 1 ;
break ;
2022-01-02 03:14:43 +01:00
case GL4DK_UP : // haut
2021-12-31 10:11:59 +01:00
_vkeyboard [ VK_UP ] = 1 ;
break ;
2022-01-02 03:14:43 +01:00
case GL4DK_LEFT : // gauche
2021-12-31 10:11:59 +01:00
_vkeyboard [ VK_LEFT ] = 1 ;
break ;
2022-01-02 03:14:43 +01:00
case GL4DK_DOWN : // bas
2021-12-31 10:11:59 +01:00
_vkeyboard [ VK_DOWN ] = 1 ;
break ;
2022-01-02 03:14:43 +01:00
case GL4DK_RETURN : // pose de bombe
_vkeyboard [ VK_RETURN ] = 1 ;
break ;
2022-01-02 02:28:03 +01:00
/* Joueur B */
2022-01-02 03:14:43 +01:00
case GL4DK_d : // droite
2021-12-31 10:44:28 +01:00
_vkeyboard [ VK_d ] = 1 ;
break ;
2022-01-02 03:14:43 +01:00
case GL4DK_z : // haut
2021-12-31 10:44:28 +01:00
_vkeyboard [ VK_z ] = 1 ;
break ;
2022-01-02 03:14:43 +01:00
case GL4DK_q : // gauche
2021-12-31 10:44:28 +01:00
_vkeyboard [ VK_q ] = 1 ;
break ;
2022-01-02 03:14:43 +01:00
case GL4DK_s : // bas
2021-12-31 10:44:28 +01:00
_vkeyboard [ VK_s ] = 1 ;
break ;
2022-01-02 03:14:43 +01:00
case GL4DK_SPACE : // pose de bombe
_vkeyboard [ VK_SPACE ] = 1 ;
break ;
2021-12-31 10:44:28 +01:00
/* Par défaut on ne fais rien */
default : break ;
2021-12-31 10:11:59 +01:00
}
}
2021-12-31 15:07:16 +01:00
/*!\brief Intercepte l'évènement clavier pour modifier les options (au relâchement d'une touche). */
2021-12-31 10:11:59 +01:00
void keyu ( int keycode ) {
switch ( keycode ) {
2022-01-02 02:28:03 +01:00
/* Cas où l'Joueur A on arrête de bouger */
2021-12-31 10:11:59 +01:00
case GL4DK_RIGHT :
_vkeyboard [ VK_RIGHT ] = 0 ;
break ;
case GL4DK_UP :
_vkeyboard [ VK_UP ] = 0 ;
break ;
case GL4DK_LEFT :
_vkeyboard [ VK_LEFT ] = 0 ;
break ;
case GL4DK_DOWN :
_vkeyboard [ VK_DOWN ] = 0 ;
break ;
2022-01-02 02:28:03 +01:00
/* Cas où l'Joueur A on arrête de bouger */
2021-12-31 10:44:28 +01:00
case GL4DK_d :
_vkeyboard [ VK_d ] = 0 ;
break ;
case GL4DK_z :
_vkeyboard [ VK_z ] = 0 ;
break ;
case GL4DK_q :
_vkeyboard [ VK_q ] = 0 ;
break ;
case GL4DK_s :
_vkeyboard [ VK_s ] = 0 ;
break ;
/* Par défaut on ne fais rien */
default : break ;
2021-12-22 01:57:34 +01:00
}
}
2021-12-31 15:07:16 +01:00
/*!\brief Appeler à la sortie du programme
* pour libérer les objets de la mémoire . */
2021-12-22 01:57:34 +01:00
void sortie ( void ) {
2022-01-02 15:16:51 +01:00
/* On libère le cube */
2021-12-22 02:17:16 +01:00
if ( _cube ) {
free_surface ( _cube ) ;
_cube = NULL ;
}
2022-01-02 15:13:24 +01:00
if ( _cubeBois ) {
free_surface ( _cubeBois ) ;
_cubeBois = NULL ;
}
2021-12-31 10:11:59 +01:00
2022-01-02 15:16:51 +01:00
/* On libère la sphère */
2022-01-01 22:53:11 +01:00
if ( _sphere ) {
free_surface ( _sphere ) ;
_sphere = NULL ;
}
2022-01-02 15:16:51 +01:00
/* Libère tous les objets produits par GL4Dummies, ici
* principalement le screen */
2021-12-22 02:17:16 +01:00
gl4duClean ( GL4DU_ALL ) ;
2021-12-22 01:57:34 +01:00
}