Commit fb37d6f4 authored by Paul GEORGES's avatar Paul GEORGES
Browse files

Collisions + Camera + Murs

parent 932ed74a
#include <SDL2/SDL.h>
/* #include <SDL2/SDL.h>
#include "clavier.h"
#include <stdio.h>
/* FICHIER A RENOMMER */
ListeB tir_update(ListeB LB, ListeP LP, int time, SDL_Texture *balleLongueJaune, int v){
//Si perso en train de tirer
s_ListeP *tmp = LP;
while(tmp != NULL){
if(tmp->data.tir){
//On fait pop une nouvelle balle toutes les X ms
if(time > tmp->data.tempsTirPrecedent + 200) {
LB = cons_listeB(LB, nouvelle_balle(balleLongueJaune, tmp->data.angle, tmp->data.pos));
tmp->data.tempsTirPrecedent = time;
}
}
tmp = tmp->next;
}
//On met a jour les coordonnes des balles dj tires, dpop si ncssaire
LB = incrementer_balles(LB, v);
return LB;
}
void animer_persos(ListeP L){
s_ListeP *tmp = L;
......@@ -29,3 +14,6 @@ void animer_persos(ListeP L){
animer_perso(&tmp->data);
return;
}
*/
#include <SDL2/SDL.h>
#include "listeP.h"
/*#include <SDL2/SDL.h>
#include "listeB.h"
/* FICHIER A RENOMMER */
ListeB tir_update(ListeB LB, ListeP LP, int time, SDL_Texture *balleLongueJaune, int v);
void animer_persos(ListeP L);
void animer_persos(ListeP L);*/
#include "image.h"
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
SDL_Texture* charger_image(const char* cheminFichier, SDL_Renderer* renderer)
SDL_Texture* charger_image(const char* cheminFichier, SDL_Renderer* renderer, int r, int g, int b)
{
SDL_Surface* surface = IMG_Load(cheminFichier);
SDL_SetColorKey(surface, SDL_TRUE, SDL_MapRGB(surface->format, 255, 255, 255 ));
if(r >= 0 && g >= 0 && b >= 0){
SDL_SetColorKey(surface, SDL_TRUE, SDL_MapRGB(surface->format, r, g, b ));
}
SDL_Texture* image = SDL_CreateTextureFromSurface(renderer, surface);
SDL_FreeSurface(surface);
return image;
}
void afficher_niveau(int *tab, SDL_Renderer *renderer, SDL_Texture **spriteMap, int xCamera, int yCamera){
SDL_Rect destrect;
destrect.h = 50;
destrect.w = 50;
for(int j = 0; j < 30; j++){
for(int i = 0; i < 30; i++){
destrect.x = i * 50 - xCamera;
destrect.y = j * 50 - yCamera;
SDL_RenderCopy(renderer, spriteMap[0], NULL, &destrect);
for(int k = 1; k < 9; k++){
if(tab[30*j+i] == k){
SDL_RenderCopy(renderer, spriteMap[k], NULL, &destrect);
}
}
}
}
return;
}
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
SDL_Texture* charger_image(const char* fichier, SDL_Renderer* renderer);
SDL_Texture* charger_image(const char* fichier, SDL_Renderer* renderer, int r, int g, int b);
void afficher_niveau(int *tab, SDL_Renderer *renderer, SDL_Texture **spriteMap, int xCamera, int yCamera);
#include <stdio.h>
#include <stdlib.h>
#include "listeB.h"
ListeB nouvelle_listeB(balle data){
ListeB L = malloc(sizeof(s_ListeB));
L->data = data;
......@@ -21,23 +20,42 @@ bool est_vide_listeB(ListeB L) {
}
ListeB incrementer_balles(ListeB L, int v)
ListeB incrementer_balles(ListeB LB, ListeP LP, ListeR LR, int v, int xCamera, int yCamera)
{
if(L == NULL){
return L;
if(LB == NULL){
return LB;
}
//L->data = incrementer_balle(L->data, v);
incrementer_balle(&L->data, v);
incrementer_balle(&LB->data, v);
if(L->data.ballePos.x <= -60 || L->data.ballePos.x >= 1000 || L->data.ballePos.y <= -60 || L->data.ballePos.y >= 720){
L = L->next;
return incrementer_balles(L, v);
} else {
L->next = incrementer_balles(L->next, v);
return L;
SDL_Rect ballePos;
ballePos.w = 1;
ballePos.h = 1;
ballePos.x = LB->data.ballePos.x + 20;
ballePos.y = LB->data.ballePos.y + 20;
if(ballePos.x < 0 || ballePos.x >= 1000 || ballePos.y <= 0 || ballePos.y >= 700
|| detecter_collision_murs(LR, ballePos, xCamera, yCamera)){
LB = LB->next;
return incrementer_balles(LB, LP, LR, v, xCamera, yCamera);
}
ballePos.w = 6;
ballePos.h = 6;
ballePos.x = LB->data.ballePos.x - 3;
ballePos.y = LB->data.ballePos.y - 3;
if(detecter_collision_perso(LP, ballePos, xCamera, yCamera)) {
LB = LB->next;
return incrementer_balles(LB, LP, LR, v, xCamera, yCamera);
}
LB->next = incrementer_balles(LB->next, LP, LR, v, xCamera, yCamera);
return LB;
return NULL;
}
......@@ -49,3 +67,21 @@ void afficher_listeB(SDL_Renderer *renderer, ListeB L) {
}
}
ListeB tir_update(ListeB LB, ListeP LP, ListeR LR, int time, SDL_Texture *balleLongueJaune, int v, int xCamera, int yCamera){
//Si perso en train de tirer
s_ListeP *tmp = LP;
while(tmp != NULL){
if(tmp->data.tir){
//On fait pop une nouvelle balle toutes les X ms
if(time > tmp->data.tempsTirPrecedent + 200) {
LB = cons_listeB(LB, nouvelle_balle(balleLongueJaune, tmp->data.angle, tmp->data.pos));
tmp->data.tempsTirPrecedent = time;
}
}
tmp = tmp->next;
}
//On met a jour les coordonnes des balles dj tires, dpop si ncssaire
LB = incrementer_balles(LB, LP, LR, v, xCamera, yCamera);
return LB;
}
#include "projectile.h"
#include <stdbool.h>
#include <stdio.h>
#include "projectile.h"
#include "listeP.h"
typedef struct s_ListeB *ListeB, s_ListeB;
struct s_ListeB
......@@ -11,5 +12,6 @@ struct s_ListeB
ListeB nouvelle_listeB(balle data);
ListeB cons_listeB(ListeB L, balle data);
bool est_vide_listeB(ListeB L);
ListeB incrementer_balles(ListeB L, int v);
ListeB incrementer_balles(ListeB LB, ListeP LP, ListeR LR, int v, int xCamera, int yCamera);
void afficher_listeB(SDL_Renderer *renderer, ListeB L);
ListeB tir_update(ListeB LB, ListeP LP, ListeR LR, int time, SDL_Texture *balleLongueJaune, int v, int xCamera, int yCamera);
#include <stdio.h>
#include <stdlib.h>
#include "listeP.h"
ListeP nouvelle_listeP(Perso data){
ListeP L = malloc(sizeof(s_ListeP));
L->data = data;
L->next = NULL;
return L;
};
}
ListeP cons_listeP(ListeP L, Perso data){
ListeP tmp = nouvelle_listeP(data);
......@@ -38,3 +37,57 @@ Perso* joueur(ListeP L){
}
return NULL;
}
ListeP deplacement_ennemis(ListeP L, int xCamera, int yCamera, int dxCamera, int dyCamera){
if(L == NULL){
return L;
}
s_ListeP *tmp = L;
while(tmp != NULL){
deplacement_ennemi(&tmp->data, xCamera, yCamera, dxCamera, dyCamera);
tmp = tmp->next;
}
return L;
}
bool detecter_collision_perso(ListeP L, SDL_Rect rect, int xCamera, int yCamera){
int ax1, ax2, bx1, bx2, ay1, ay2, by1, by2;
while(L != NULL){
ax1 = rect.x;//+ xCamera;
ax2 = rect.x + rect.w ;//+ xCamera;
bx1 = L->data.pos.x;
bx2 = L->data.pos.x + L->data.pos.w;
ay1 = rect.y;// + yCamera;
ay2 = rect.y;// + rect.h + yCamera;
by1 = L->data.pos.y;
by2 = L->data.pos.y + L->data.pos.h;
if(ax1 < bx2 && ax2 > bx1 && ay1 < by2 && ay2 > by1 && L->data.ennemi){
return true;
}
L = L->next;
}
return false;
}
void animer_persos2(ListeP L){
while(L != NULL){
if(L->data.ennemi){
animer_perso(&L->data);
}
L = L->next;
}
}
void animer_persos(ListeP L){
animer_persos2(L);
return;
}
#include "personnage.h"
#include <stdbool.h>
#include "personnage.h"
#include <stdio.h>
typedef struct s_ListeP *ListeP, s_ListeP;
struct s_ListeP
......@@ -13,5 +14,7 @@ ListeP cons_listeP(ListeP L, Perso data);
bool est_vide_listeP(ListeP L);
void afficher_listeP(SDL_Renderer *renderer, ListeP L);
Perso* joueur(ListeP L);
ListeP deplacement_ennemis(ListeP L, int xCamera, int yCamera, int dxCamera, int dyCamera);
bool detecter_collision_perso(ListeP L, SDL_Rect rect, int xCamera, int yCamera);
void animer_persos(ListeP L);
void animer_persos2(ListeP L);
#include "listeR.h"
ListeR nouvelle_listeR(SDL_Rect data){
ListeR L = malloc(sizeof(s_ListeR));
L->data = data;
L->next = NULL;
return L;
}
ListeR cons_listeR(ListeR L, SDL_Rect data){
ListeR tmp = nouvelle_listeR(data);
tmp->next = L;
return tmp;
}
ListeR charger_niveau(int *tab, ListeR L){
//on met toutes les case 0 pour dire que tout est du sol (provisoire)
for(int j = 0; j < 30; j++){
for(int i = 0; i < 30; i++){
tab[30*j+i] = 0;
}
}
//ici lire fichier et remplacer les cases qu'il faut par 1-8 pour mettre des murs
//je mets a en attendant pour afficher des murs sur le bord de la map
for(int j = 0; j < 30; j++){
tab[30*j+0] = 3;
tab[30*j+29] = 4;
tab[30*0+j] = 1;
tab[30*29+j] = 2;
}
tab[30*0+0] = 5;
tab[30*0+29] = 6;
tab[30*29+0] = 7;
tab[30*29+29] = 8;
//Remplir la liste de murs
SDL_Rect rect;
for(int j = 0; j < 30; j++){
for(int i = 0; i < 30; i++){
switch(tab[30*j+i]){
case 0:
break;
case 1:
rect.x = i * 50;
rect.y = j * 50;
rect.h = 25;
rect.w = 50;
L = cons_listeR(L, rect);
break;
case 2:
rect.x = i * 50;
rect.y = j * 50 + 25;
rect.h = 25;
rect.w = 50;
L = cons_listeR(L, rect);
break;
case 3:
rect.x = i * 50;
rect.y = j * 50;
rect.h = 50;
rect.w = 25;
L = cons_listeR(L, rect);
break;
case 4:
rect.x = i * 50 + 25;
rect.y = j * 50;
rect.h = 50;
rect.w = 25;
L = cons_listeR(L, rect);
break;
case 5:
case 6:
case 7:
case 8:
rect.x = i * 50;
rect.y = j * 50;
rect.h = 50;
rect.w = 50;
L = cons_listeR(L, rect);
break;
}
}
}
return L;
}
bool detecter_collision_murs(ListeR L, SDL_Rect rect, int xCamera, int yCamera){
s_ListeR *tmp = L;
int ax1, ax2, bx1, bx2, ay1, ay2, by1, by2;
while(tmp != NULL){
ax1 = rect.x + xCamera;
ax2 = rect.x + rect.w + xCamera;
bx1 = tmp->data.x;
bx2 = tmp->data.x + tmp->data.w;
ay1 = rect.y + yCamera;
ay2 = rect.y + rect.h + yCamera;
by1 = tmp->data.y;
by2 = tmp->data.y + tmp->data.h;
if(ax1 < bx2 && ax2 > bx1 && ay1 < by2 && ay2 > by1){
return true;
}
tmp = tmp->next;
}
return false;
}
#include <SDL2/SDL.h>
#include <stdlib.h>
#include <stdbool.h>
typedef struct s_ListeR *ListeR, s_ListeR;
struct s_ListeR
{
ListeR next;
SDL_Rect data;
};
ListeR nouvelle_listeR(SDL_Rect data);
ListeR cons_listeR(ListeR L, SDL_Rect data);
ListeR charger_niveau(int *tab, ListeR L);
bool detecter_collision_murs(ListeR L, SDL_Rect rect, int xCamera, int yCamera);
#include <SDL2/SDL.h>
#include <SDL2/SDL_image.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <time.h>
#include "image.h"
#include "clavier.h"
#define RAYON 30.9
int main(int argc, char *argv[])
{
srand(time(NULL));
bool gameover = false;
bool tir = false;
SDL_Window *fenetre;
SDL_Event evenements;
SDL_Renderer *ecran;
SDL_Texture *fond, *perso, *balleLongueJaune, *mur;
SDL_Rect persoPos;
float mouseX, mouseY;
int vitesse = 25, tempsActuel = 0, tempsPrecedent = 0, tempsActuelTir = 0, tempsActuelAnim = 0, tempsPrecedentAnim = 0;
ListeB ballesTirees;
ListeP persosListe;
Perso *joueur_ptr;
SDL_Texture *sprites[3];
SDL_Rect mur1;
mur1.x = 500;
mur1.y = 500;
mur1.h = 100;
mur1.w = 104;
SDL_Rect mur2;
mur2.x = 10;
mur2.y = 10;
mur2.h = 56;
mur2.w = 47;
SDL_Rect mur3;
mur3.x = 500;
mur3.y = 659;
mur3.h = 85;
mur3.w = 500;
SDL_Rect tabMur[3];
tabMur[0] = mur1;
tabMur[1] = mur2;
tabMur[2] = mur3;
/**
FILE* fichier = NULL;
fichier = fopen("map.txt", "r");
char caractereActuel;
char nombre = "";
if (fichier != NULL){
// Boucle de lecture des caract�res un � un
int i = 0;
do
{
if( 'M' == fgetc(fichier)){ // On lit le caract�re
printf("J'ai trouv� un mur !");
caractereActuel = fgetc(fichier);
while(caractereActuel != ':'){
caractereActuel = fgetc(fichier);
nombre = nombre + caractereActuel;
printf("%c", nombre);
}
printf("%c", nombre);
tabMur[i].x = nombre;
while(caractereActuel != ':'){
caractereActuel = fgetc(fichier);
}
while(caractereActuel != ':'){
caractereActuel = fgetc(fichier);
}
tabMur[i].y = fgetc(fichier);
while(caractereActuel != ':'){
caractereActuel = fgetc(fichier);
}
tabMur[i].w = fgetc(fichier);
while(caractereActuel != ':'){
caractereActuel = fgetc(fichier);
}
tabMur[i].h = fgetc(fichier);
i++;
}
else{
caractereActuel = fgetc(fichier);
}
} while (caractereActuel != EOF); // On continue tant que fgetc n'a pas retourn� EOF (fin de fichier)
fclose(fichier);
}
*/
//Initialisation SDL
if(SDL_Init(SDL_INIT_VIDEO < 0))
{
printf("Erreur d'initialisation de la SDL %s", SDL_GetError());
SDL_Quit();
return EXIT_FAILURE;
}
IMG_Init(IMG_INIT_PNG);
//Création fenêtre
fenetre = SDL_CreateWindow("gameName", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 1000, 720, SDL_WINDOW_RESIZABLE);
if(fenetre == NULL)
{
printf("Erreur d'initialisation de la fenetre %s", SDL_GetError());
return EXIT_FAILURE;
}
//Création renderer
ecran = SDL_CreateRenderer(fenetre, -1, SDL_RENDERER_ACCELERATED);
//Chargement images
balleLongueJaune = charger_image("sprites/projectiles/balle/balle_longue_jaune.png", ecran);
fond = charger_image("sprites/fond.png", ecran);
mur = charger_image("sprites/mur.png", ecran);
perso = charger_image("sprites/perso/handgun/idle/survivor_idle.png", ecran);
sprites[0] = perso;
perso = charger_image("sprites/perso/handgun/move/survivor_moving.png", ecran);
sprites[1] = perso;
perso = charger_image("sprites/perso/ennemi_1.png", ecran);
sprites[2] = perso;
Perso p = nouveau_joueur(ecran , sprites);
persosListe = nouvelle_listeP(p);
p = nouvel_ennemi_1(ecran, sprites);
persosListe = cons_listeP(persosListe, p);
//Pareil pour la balle + ses autres paramètres (voir projectile.h)
balle b = nouvelle_balle(balleLongueJaune, 0, persoPos);
ballesTirees = nouvelle_listeB(b);
//Boucle de jeu
while(!gameover)
{
//Petit timer pour pas dépasser 60 exécutions/sec (provisoire)
tempsActuel = SDL_GetTicks();
if (tempsActuel > tempsPrecedent + 16)
{
//Détection événements
while(SDL_PollEvent(&evenements))
{
switch(evenements.type)
{
case SDL_QUIT:
gameover = true;
break;
case SDL_MOUSEMOTION:
mouseX = evenements.motion.x;
mouseY = evenements.motion.y;
break;
case SDL_MOUSEBUTTONDOWN:
switch(evenements.button.button)
{
case SDL_BUTTON_LEFT:
tir = true;
break;
}
break;
case SDL_MOUSEBUTTONUP:
switch(evenements.button.button)
{
case SDL_BUTTON_LEFT:
tir = false;
break;
}
break;
case SDL_KEYDOWN:
switch(evenements.key.keysym.sym)
{
case SDLK_ESCAPE:
gameover = true;
break;
}
break;
}
}
joueur_ptr = joueur(persosListe);
joueur_ptr->tir = tir;
tempsActuelAnim = SDL_GetTicks();
if(tempsActuelAnim > tempsPrecedentAnim + 70 ){
animer_persos(persosListe);