/*!\file window.c * \author Farès BELHADJ, amsi@up8.edu * \student Anri KENNEL, anri.kennel@etud.univ-paris8.fr * \date November 16, 2021. */ #include #include /* Inclusion des entêtes de fonctions de gestion de primitives simples * de dessin. La lettre p signifie aussi bien primitive que * pédagogique. */ #include /* Inclure la bibliothèque de rendu du cours */ #include "rasterize.h" /* Inclusion des entêtes de fonctions de création et de gestion de * fenêtres système ouvrant un contexte favorable à GL4dummies. Cette * partie est dépendante de la bibliothèque SDL2 */ #include /* Fonctions locales (static) */ static void init(void); static void idle(void); static void draw(void); static void keyu(int keycode); static void keyd(int keycode); static void sortie(void); /*!\brief Surface représentant un cube */ static surface_t * _cube = NULL; static float _cubeSize = 4.f; /*!\brief Surface représentant une sphère */ static surface_t * _sphere = NULL; /*!\brief Variable d'état pour activer/désactiver la synchronisation verticale */ static int _use_vsync = 1; /*!\brief Variable d'état pour activer/désactiver le debug */ static int _debug = 0; /*!\brief Grille de positions où il y aura des cubes * 0 -> Vide * 1 -> Mur * 2 (valeur reservée) -> Joueur A (défini automatiquement par le programme) * 3 (valeur reservée) -> Joueur B (défini automatiquement par le programme) * 4 -> Bloc destructible */ static int * _plateau = NULL; /*!\brief Largeur/Nombre de lignes de la grille */ static int _grilleW; /*!\brief Hauteur/Nombre de colonnes de la grille */ static int _grilleH; /* Définition d'un personnage */ typedef struct perso_t { float x, y, z; /* Coordonées spatiale */ int position; /* Position dans la grille. * Permet d'éviter aux joueurs * de se rentrer dedans */ } perso_t; /* Définition de nos deux joueurs */ perso_t _joueurA = { 0.f, 0.f, 0.f, -1 }; // à droite perso_t _joueurB = { 0.f, 0.f, 6.f, -1 }; // à gauche /* Clavier virtuel */ enum { /* Joueur A */ VK_RIGHT = 0, VK_UP, VK_LEFT, VK_DOWN, /* Joueur B */ VK_d, VK_z, VK_q, VK_s, /* Toujours à la fin */ VK_SIZEOF }; int _vkeyboard[VK_SIZEOF] = {0, 0, 0, 0, 0, 0, 0, 0}; /*!\brief Paramètre l'application et lance la boucle infinie. */ int main(int argc, char ** argv) { /* Tentative de création d'une fenêtre pour GL4Dummies */ if(!gl4duwCreateWindow(argc, argv, /* args du programme */ "Bomberman ⋅ A. KENNEL L2-A", /* titre */ 10, 10, 800, 600, /* x, y, largeur, heuteur */ GL4DW_SHOWN) /* état visible */) { /* Ici si échec de la création souvent lié à un problème d'absence * de contexte graphique ou d'impossibilité d'ouverture d'un * contexte OpenGL (au moins 3.2) */ return 1; } init(); /* Mets en place la fonction d'interception clavier touche pressée */ gl4duwKeyDownFunc(keyd); /* Mets en place la fonction d'interception clavier touche relachée */ gl4duwKeyUpFunc(keyu); /* Mets en place la fonction idle (simulation, au sens physique du terme) */ gl4duwIdleFunc(idle); /* Mets en place la fonction de display */ gl4duwDisplayFunc(draw); /* Boucle infinie pour éviter que le programme ne s'arrête et ferme * la fenêtre immédiatement */ gl4duwMainLoop(); return 0; } /*!\brief init de nos données, spécialement le plateau */ void init(void) { GLuint id; /* Création d'un screen GL4Dummies (texture dans laquelle nous * pouvons dessiner) aux dimensions de la fenêtre. IMPORTANT de * créer le screen avant d'utiliser les fonctions liées au * textures */ gl4dpInitScreen(); /* Création du cube */ _cube = mk_cube(); /* ça fait 2x6 triangles */ _sphere = mk_sphere(12, 12); /* ça fait 12x12 triangles */ /* Rajoute la texture */ id = get_texture_from_BMP("images/tex.bmp"); set_texture_id(_cube, id); set_texture_id(_sphere, id); /* Affichage des textures */ enable_surface_option(_cube, SO_USE_TEXTURE); enable_surface_option(_sphere, SO_USE_TEXTURE); /* Affichage des ombres */ enable_surface_option(_cube, SO_USE_LIGHTING); enable_surface_option(_sphere, SO_USE_LIGHTING); /* Si _use_vsync != 0, on active la synchronisation verticale */ SDL_GL_SetSwapInterval(_use_vsync); /* Génération du plateau * et placement des joueurs */ srand(time(NULL)); /* Génération des dimensions du plateau */ _grilleW = 15 + (rand() % 10); _grilleH = _grilleW; /* Placement des joueurs */ // TODO... les faires relativement éloignes l'un de l'autre int coefEloignement = _grilleW * 1.1; /* Joueur A */ _joueurA.x += coefEloignement; _joueurA.z += coefEloignement; /* Joueur B */ _joueurB.x -= coefEloignement; _joueurB.z -= coefEloignement; if ((_plateau = malloc((_grilleW * _grilleH) * sizeof(int))) == NULL) { printf("Impossible d'allouer de la mémoire supplémentaire pour générer le plateau.\n"); sortie(); exit(1); } /* Génération du plateau */ int _curseur = 0; for(int i = 0; i < _grilleH; i++) for(int j = 0; j < _grilleW; j++) { if (i == 0) { // mur en haut _plateau[_curseur] = 1; _curseur++; continue; } if (i == (_grilleH - 1)) { // mur en bas _plateau[_curseur] = 1; _curseur++; continue; } if (j == 0) { // mur a gauche _plateau[_curseur] = 1; _curseur++; continue; } if (j == (_grilleW - 1)) { // mur a droite _plateau[_curseur] = 1; _curseur++; continue; } if ((j % 2) == 0 && (i % 2) == 0) { // mur à l'intérieur _plateau[_curseur] = 1; _curseur++; continue; } _plateau[_curseur] = 0; _curseur++; } /* On s'assure que au moins une cases autours du joueurs sont libre * ça donne ça : * 0 0 0 * 0 x 0 * 0 0 0 */ int caseJoueurA = round((_joueurA.z + _cubeSize * _grilleH / 2) / _cubeSize) * _grilleH + round((_joueurA.x + _cubeSize * _grilleW / 2) / _cubeSize); int caseJoueurB = round((_joueurB.z + _cubeSize * _grilleH / 2) / _cubeSize) * _grilleH + round((_joueurB.x + _cubeSize * _grilleW / 2) / _cubeSize); for(int i = 1; i <= 2; i++) { /* Attention au bordures ! * On les fait spawn loin des bordures * pour éviter tout problèmes. */ /* Joueur A */ _plateau[caseJoueurA - i] = 0; // gauche _plateau[caseJoueurA + i] = 0; // droite _plateau[caseJoueurA - _grilleW - i] = 0; // haut _plateau[caseJoueurA + _grilleW + i] = 0; // bas /* Joueur B */ _plateau[caseJoueurB - i] = 0; // gauche _plateau[caseJoueurB + i] = 0; // droite _plateau[caseJoueurB - _grilleW - i] = 0; // haut _plateau[caseJoueurB + _grilleW + i] = 0; // bas } /* Mets en place la fonction à appeler en cas de sortie */ atexit(sortie); } /*!\brief Fonction appellée à chaque idle (entre chaque frame) */ 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 /* pour le frame d'après, mets à-jour t0 */ t0 = t; float vitesse = 10.f; // vitesse des joueurs /* Calcul du décalage */ float decalageAutorisee = .2f; // décalage autorisé, modifier cette valeur si nécessaire float decalageGB = .0f + decalageAutorisee; // décalage pour la gauche et le bas float decalageDH = 1.f - decalageAutorisee; // décalage pour la droite et le haut /* Mouvements du Joueur A */ /* Coordonées x, z */ float zA = (_joueurA.z + _cubeSize * _grilleH / 2) / _cubeSize; // ligne - hauteur float xA = (_joueurA.x + _cubeSize * _grilleW / 2) / _cubeSize; // colonne - longueur /* Coordonnées joueur A */ int coorJoueurA = round(zA) * _grilleH + round(xA); int coorDroiteA = round(zA) * _grilleH + ceil(xA); int coorHautA = floor(zA) * _grilleH + round(xA); int coorGaucheA = round(zA) * _grilleH + floor(xA); int coorBasA = ceil(zA) * _grilleH + round(xA); /* Décalage pour éviter bug de collisions */ float decalageLargeurA = zA - floor(zA); float decalageLongueurA = xA - floor(xA); /* Déplacement */ if(_vkeyboard[VK_RIGHT]) if((_plateau[coorDroiteA] == 0 || _plateau[coorDroiteA] == 2) && (decalageLargeurA < decalageGB || decalageLargeurA > decalageDH)) // collision à droite du plateau _joueurA.x += vitesse * dt; if(_vkeyboard[VK_UP]) if((_plateau[coorHautA] == 0 || _plateau[coorHautA] == 2) && (decalageLongueurA < decalageGB || decalageLongueurA > decalageDH)) // collision en haut du plateau _joueurA.z -= vitesse * dt; if(_vkeyboard[VK_LEFT]) if((_plateau[coorGaucheA] == 0 || _plateau[coorGaucheA] == 2) && (decalageLargeurA < decalageGB || decalageLargeurA > decalageDH)) // collision à gauche du plateau _joueurA.x -= vitesse * dt; if(_vkeyboard[VK_DOWN]) if((_plateau[coorBasA] == 0 || _plateau[coorBasA] == 2) && (decalageLongueurA < decalageGB || decalageLongueurA > decalageDH)) // collision en bas du plateau _joueurA.z += vitesse * dt; /* Affichage Debug */ if(_debug) { printf("\n========== Joueur A ==========\n"); printf(" li = %d, col = %d, idx = %d\n", (int)(zA + .5f), (int)(xA + .5f), _joueurA.position); printf(" zA=%f xA=%f\n", zA, xA); printf(" d=%d h=%d g=%d b=%d\n", coorDroiteA, coorHautA, coorGaucheA, coorBasA); } /* Anti-collision entre joueurs */ if(_joueurA.position != coorJoueurA) { if(_joueurA.position != -1) _plateau[_joueurA.position] = 0; _joueurA.position = coorJoueurA; _plateau[coorJoueurA] = 2; } /* Mouvements du Joueur B */ /* Coordonées x, z */ float zB = (float)((_joueurB.z + _cubeSize * _grilleH / 2) / _cubeSize); // ligne - hauteur float xB = (float)((_joueurB.x + _cubeSize * _grilleW / 2) / _cubeSize); // colonne - longueur /* Coordonnées joueur A */ int coorJoueurB = round(zB) * _grilleH + round(xB); int coorDroiteB = round(zB) * _grilleH + ceil(xB); int coorHautB = floor(zB) * _grilleH + round(xB); int coorGaucheB = round(zB) * _grilleH + floor(xB); int coorBasB = ceil(zB) * _grilleH + round(xB); /* Décalage pour éviter bug de collisions */ float decalageLargeurB = zB - floor(zB); float decalageLongueurB = xB - floor(xB); /* Déplacement */ if(_vkeyboard[VK_d]) if((_plateau[coorDroiteB] == 0 || _plateau[coorDroiteB] == 3) && (decalageLargeurB < decalageGB || decalageLargeurB > decalageDH)) // collision à droite du plateau _joueurB.x += vitesse * dt; if(_vkeyboard[VK_z]) if((_plateau[coorHautB] == 0 || _plateau[coorHautB] == 3) && (decalageLongueurB < decalageGB || decalageLongueurB > decalageDH)) // collision en haut du plateau _joueurB.z -= vitesse * dt; if(_vkeyboard[VK_q]) if((_plateau[coorGaucheB] == 0 || _plateau[coorGaucheB] == 3) && (decalageLargeurB < decalageGB || decalageLargeurB > decalageDH)) // collision à gauche du plateau _joueurB.x -= vitesse * dt; if(_vkeyboard[VK_s]) if((_plateau[coorBasB] == 0 || _plateau[coorBasB] == 3) && (decalageLongueurB < decalageGB || decalageLongueurB > decalageDH)) // collision en bas du plateau _joueurB.z += vitesse * dt; /* Affichage Debug */ if(_debug) { printf("========== Joueur B ==========\n"); printf(" li = %d, col = %d, idx = %d\n", (int)(zB + .5f), (int)(xB + .5f), _joueurB.position); printf(" zA=%f xA=%f\n", zB, xB); printf(" d=%d h=%d g=%d b=%d\n", coorDroiteB, coorHautB, coorGaucheB, coorBasB); printf("===============================\n"); } /* Anti-collision entre joueurs */ if(_joueurB.position != coorJoueurB) { if(_joueurB.position != -1) _plateau[_joueurB.position] = 0; _joueurB.position = coorJoueurB; _plateau[coorJoueurB] = 3; } } /*!\brief Fonction appelée à chaque display. */ void draw(void) { vec4 couleurPlateau = {0.2, 0.2, 0.2, 1} /* Gris */, couleurJoueurA = {0.15, 0.5, 0.15, 1} /* Vert */, couleurJoueurB = {0.2, 0.2, 0.7, 1} /* Bleu */, couleurBois = {0.6, 0.3, 0, 0} /* Marron */; float model_view_matrix[16], projection_matrix[16], nmv[16]; /* Efface l'écran et le buffer de profondeur */ gl4dpClearScreen(); clear_depth_map(); /* Des macros facilitant le travail avec des matrices et des * vecteurs se trouvent dans la bibliothèque GL4Dummies, dans le * fichier gl4dm.h */ /* Charger un frustum dans projection_matrix */ MFRUSTUM(projection_matrix, -0.05f, 0.05f, -0.05f, 0.05f, 0.1f, 1000.0f); /* Charger la matrice identité dans model-view */ MIDENTITY(model_view_matrix); /* On place la caméra en arrière-haut, elle regarde le centre de la scène */ int coefTaille = -20 + _grilleW * 2.5; lookAt(model_view_matrix, 0, 70 + coefTaille /* zoom */, 30 + coefTaille /* inclinaison */, 0, 0, 0, 0, 0, -1); /* Pour centrer la grille par rapport au monde */ float cX = -_cubeSize * _grilleW / 2.0f; float cZ = -_cubeSize * _grilleH / 2.0f; /* Pour toutes les cases de la grille, afficher un cube quand il y a * un 1 dans la grille */ for(int i = 0; i < _grilleW; ++i) for(int j = 0; j < _grilleH; ++j) { /* Bloc simple */ if(_plateau[i * _grilleW + j] == 1) { _cube->dcolor = couleurPlateau; /* copie model_view_matrix dans nmv */ memcpy(nmv, model_view_matrix, sizeof(nmv)); /* pour convertir les coordonnées i, j de la grille en x, z du monde */ translate(nmv, _cubeSize * j + cX, 0.0f, _cubeSize * i + cZ); scale(nmv, _cubeSize / 2.0f, _cubeSize / 2.0f, _cubeSize / 2.0f); transform_n_rasterize(_cube, nmv, projection_matrix); } /* Bloc destructible */ if(_plateau[i * _grilleW + j] == 4) { _cube->dcolor = couleurBois; /* copie model_view_matrix dans nmv */ memcpy(nmv, model_view_matrix, sizeof(nmv)); /* pour convertir les coordonnées i, j de la grille en x, z du monde */ translate(nmv, _cubeSize * j + cX, 0.0f, _cubeSize * i + cZ); scale(nmv, _cubeSize / 2.0f, _cubeSize / 2.0f, _cubeSize / 2.0f); transform_n_rasterize(_cube, nmv, projection_matrix); } } /* Dessine le Joueur A */ _cube->dcolor = couleurJoueurA; _sphere->dcolor = couleurJoueurA; memcpy(nmv, model_view_matrix, sizeof(nmv)); /* Corps */ translate(nmv, _joueurA.x, _joueurA.y, _joueurA.z); scale(nmv, _cubeSize / 3.0f, _cubeSize / 3.0f, _cubeSize / 3.0f); transform_n_rasterize(_cube, nmv, projection_matrix); /* Tête */ translate(nmv, 0.0f, 2.0f, 0.0f); transform_n_rasterize(_sphere, nmv, projection_matrix); /* Dessine le Joueur B */ _cube->dcolor = couleurJoueurB; _sphere->dcolor = couleurJoueurB; memcpy(nmv, model_view_matrix, sizeof(nmv)); /* Corps */ translate(nmv, _joueurB.x, _joueurB.y, _joueurB.z); scale(nmv, _cubeSize / 3.0f, _cubeSize / 3.0f, _cubeSize / 3.0f); transform_n_rasterize(_cube, nmv, projection_matrix); /* Tête */ translate(nmv, 0.0f, 2.0f, 0.0f); transform_n_rasterize(_sphere, nmv, projection_matrix); /* Déclare que l'on a changé des pixels de l'écran (bas niveau) */ gl4dpScreenHasChanged(); /* Fonction permettant de raffraîchir l'ensemble de la fenêtre*/ gl4dpUpdateScreen(NULL); } /*!\brief Intercepte l'événement clavier pour modifier les options (à l'appuie d'une touche). */ void keyd(int keycode) { switch(keycode) { /* 'v' utiliser la sync Verticale */ case GL4DK_v: _use_vsync = !_use_vsync; if(_use_vsync) SDL_GL_SetSwapInterval(1); else SDL_GL_SetSwapInterval(0); break; /* 'h' afficher ou non les infos de debug */ case GL4DK_h: _debug = !_debug; break; /* Joueur A */ case GL4DK_RIGHT: _vkeyboard[VK_RIGHT] = 1; break; case GL4DK_UP: _vkeyboard[VK_UP] = 1; break; case GL4DK_LEFT: _vkeyboard[VK_LEFT] = 1; break; case GL4DK_DOWN: _vkeyboard[VK_DOWN] = 1; break; /* Joueur B */ case GL4DK_d: _vkeyboard[VK_d] = 1; break; case GL4DK_z: _vkeyboard[VK_z] = 1; break; case GL4DK_q: _vkeyboard[VK_q] = 1; break; case GL4DK_s: _vkeyboard[VK_s] = 1; break; /* Par défaut on ne fais rien */ default: break; } } /*!\brief Intercepte l'évènement clavier pour modifier les options (au relâchement d'une touche). */ void keyu(int keycode) { switch(keycode) { /* Cas où l'Joueur A on arrête de bouger */ 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; /* Cas où l'Joueur A on arrête de bouger */ 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; } } /*!\brief Appeler à la sortie du programme * pour libérer les objets de la mémoire. */ void sortie(void) { /* on libère le cube */ if(_cube) { free_surface(_cube); _cube = NULL; } /* on libère la sphère */ if(_sphere) { free_surface(_sphere); _sphere = NULL; } /* libère tous les objets produits par GL4Dummies, ici * principalement les screen */ gl4duClean(GL4DU_ALL); }