Ajout .c .h sprites

clavier.c

+#include <SDL2/SDL.h>
+#include "clavier.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;
+  tmp = tmp->next;
+  animer_perso(&tmp->data);
+  return;
+}

clavier.h

+#include <SDL2/SDL.h>
+#include "listeP.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);

image.c

+#include "image.h"
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_image.h>
+
+SDL_Texture* charger_image(const char* cheminFichier, SDL_Renderer* renderer)
+{
+  SDL_Surface* surface = IMG_Load(cheminFichier);
+  SDL_SetColorKey(surface, SDL_TRUE, SDL_MapRGB(surface->format, 255, 255, 255 ));
+  SDL_Texture* image = SDL_CreateTextureFromSurface(renderer, surface);
+  SDL_FreeSurface(surface);
+  return image;
+}
+

image.h

+#include <SDL2/SDL.h>
+
+SDL_Texture* charger_image(const char* fichier, SDL_Renderer* renderer);
+

listeB.c

+#include <stdio.h>
+#include <stdlib.h>
+#include "listeB.h"
+
+ListeB nouvelle_listeB(balle data){
+  ListeB L = malloc(sizeof(s_ListeB));
+  L->data = data;
+  L->next = NULL;
+  return L;
+}
+
+ListeB cons_listeB(ListeB L, balle data){
+  ListeB tmp;
+  tmp = nouvelle_listeB(data);
+  tmp->next = L;
+  return tmp;
+}
+
+bool est_vide_listeB(ListeB L) {
+  return (L == NULL);
+}
+
+
+ListeB incrementer_balles(ListeB L, int v)
+{
+  if(L == NULL){
+    return L;
+  }
+
+  //L->data = incrementer_balle(L->data, v);
+  incrementer_balle(&L->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;
+  }
+
+  return NULL;
+}
+
+void afficher_listeB(SDL_Renderer *renderer, ListeB L) {
+  ListeB tmp = L;
+  while(tmp != NULL) {
+    afficher_balle(renderer, tmp->data);
+    tmp = tmp->next;
+  }
+}
+

listeB.h

+#include "projectile.h"
+#include <stdbool.h>
+
+typedef struct s_ListeB *ListeB, s_ListeB;
+struct s_ListeB
+{
+    ListeB next;
+    balle data;
+};
+
+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);
+void afficher_listeB(SDL_Renderer *renderer, ListeB L);

listeP.c

+#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);
+  tmp->next = L;
+  return tmp;
+}
+
+bool est_vide_listeP(ListeP L){
+  return (L == NULL);
+}
+
+void afficher_listeP(SDL_Renderer *renderer, ListeP L){
+  ListeP tmp = L;
+  while(tmp != NULL) {
+    afficher_perso(renderer, tmp->data);
+    tmp = tmp->next;
+  }
+}
+
+Perso* joueur(ListeP L){
+  s_ListeP *tmp = L;
+  while(tmp != NULL){
+    if(tmp->data.ennemi == false){
+      return &tmp->data;
+    }
+    tmp = tmp->next;
+  }
+  return NULL;
+}

listeP.h

+#include "personnage.h"
+#include <stdbool.h>
+
+typedef struct s_ListeP *ListeP, s_ListeP;
+struct s_ListeP
+{
+    ListeP next;
+    Perso data;
+};
+
+ListeP nouvelle_listeP(Perso data);
+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);
+
+

personnage.c

+#include <time.h>
+#include <stdlib.h>
+#include "personnage.h"
+#include <math.h>
+
+#define PI 3.14159265359
+
+Perso nouveau_joueur(SDL_Renderer *renderer, SDL_Texture **sprites){
+  Perso p;
+  p.tempsTirPrecedent = 0;
+  p.image = sprites[0];
+  p.pos.x = 300;
+  p.pos.y = 300;
+  p.pos.w = 60;
+  p.pos.h = 60;
+  p.srcrect.x = 0;
+  p.srcrect.y = 0;
+  p.srcrect.w = 258;
+  p.srcrect.h = 220;
+  p.angle = 0;
+  p.vie = 100;
+  p.vitesse = 3;
+  p.tir = false;
+  p.ennemi = false;
+  p.anim = IDLE;
+  p.animFlip = 1;
+  return p;
+}
+
+Perso nouvel_ennemi_1(SDL_Renderer *renderer, SDL_Texture **sprites){
+  Perso p;
+  p.tempsTirPrecedent = 0;
+  p.image = sprites[2];
+  //gnre des coordonnes de spawn alatoires(provisoire)
+  p.pos.x = rand()%900 + 100;
+  p.pos.y = rand()%600 + 100;
+  p.pos.w = 60;
+  p.pos.h = 60;
+  p.srcrect.x = 0;
+  p.srcrect.y = 0;
+  p.srcrect.w = 258;
+  p.srcrect.h = 220;
+  p.angle = 0;
+  p.vie = 100;
+  p.vitesse = 3;
+  p.tir = false;
+  p.ennemi = true;
+  p.anim = IDLE;
+  p.animFlip = 1;
+  return p;
+}
+
+void afficher_perso(SDL_Renderer *renderer, Perso p)
+{
+  SDL_RenderCopyEx(renderer, p.image, &p.srcrect, &p.pos, p.angle, NULL, SDL_FLIP_NONE);
+}
+
+void deplacement_joueur(Perso *p)
+{
+  int dX = 0;
+  int dY = 0;
+
+  const Uint8 *state = SDL_GetKeyboardState(NULL);
+
+  if(state[SDL_GetScancodeFromKey(SDLK_z)]){
+    dY -= 1;
+  }
+
+  if(state[SDL_GetScancodeFromKey(SDLK_s)]){
+    dY += 1;
+  }
+
+  if(state[SDL_GetScancodeFromKey(SDLK_q)]){
+    dX -= 1;
+  }
+
+  if(state[SDL_GetScancodeFromKey(SDLK_d)]){
+    dX += 1;
+  }
+
+  if(dX == 2 || dX == -2){
+    dX = dX/4;
+  }
+
+  if(dY == 2 || dY == -2){
+    dY = dY/4;
+  }
+
+  p->pos.x += dX * p->vitesse;
+  p->pos.y += dY * p->vitesse;
+
+}
+
+void angle_joueur(Perso *p, float mouseX, float mouseY){
+  float angle;
+  //float dSourisPerso;
+  angle = atan2(mouseY - (p->pos.y + 30), mouseX - (p->pos.x + 30));
+  //dSourisPerso = sqrt(pow(mouseX - (p->pos.x + 30), 2) + pow(mouseY - (p->pos.y + 30), 2));
+  //angle -= atan(15./dSourisPerso);
+  angle = (angle * 180.0000)/PI;
+  p->angle = angle;
+
+  return;
+}
+
+void animer_perso(Perso *p){
+  p->srcrect.y += 216 * p->animFlip;
+  if(p->srcrect.y > 4104|| p->srcrect.y < 0){
+    p->animFlip = -p->animFlip;
+    p->srcrect.y += 216 * p->animFlip;
+  }
+  return;
+}
+

personnage.h

+#include <SDL2/SDL.h>
+#include <stdbool.h>
+#include "image.h"
+
+typedef enum AnimationType Anim;
+enum AnimationType
+{
+    IDLE, MOUVEMENT, TIR, CUT, MORT
+};
+
+typedef struct s_Personnage Perso;
+struct s_Personnage
+{
+  SDL_Rect pos;
+  SDL_Rect srcrect;
+  SDL_Texture *image;
+  float angle;
+  int tempsTirPrecedent;
+  int vie;
+  int vitesse;
+  int animFlip;
+  bool tir;
+  bool ennemi;
+  Anim anim;
+};
+
+
+Perso nouveau_joueur(SDL_Renderer *renderer, SDL_Texture **sprites);
+Perso nouvel_ennemi_1(SDL_Renderer *renderer, SDL_Texture **sprites);
+void afficher_perso(SDL_Renderer *renderer, Perso p);
+void deplacement_joueur(Perso *p);
+void angle_joueur(Perso *p, float mouseX, float mouseY);
+void animer_perso(Perso *p);

projectile.c

+#include <SDL2/SDL.h>
+#include <math.h>
+#include <stdlib.h>
+#include "projectile.h"
+
+
+#define PI 3.14159265359
+
+
+balle nouvelle_balle(SDL_Texture *image, float angle, SDL_Rect persoPos)
+{
+  balle b;
+  b.angle = angle;
+  b.collision = false;
+  b.image = image;
+  b.ballePos = persoPos;
+  return b;
+}
+
+//v = vitesse de la balle (provisoire)
+void incrementer_balle(balle *b, int v)
+{
+  b->ballePos.x += (int)(cos(b->angle * PI / 180) * v);
+  b->ballePos.y += (int)(sin(b->angle * PI / 180) * v);
+}
+
+
+
+void afficher_balle(SDL_Renderer *renderer, balle b)
+{
+  SDL_RenderCopyEx(renderer, b.image, NULL, &b.ballePos, b.angle, NULL, SDL_FLIP_NONE);
+}
+
+
+

projectile.h

+#include <SDL2/SDL.h>
+#include <stdbool.h>
+
+typedef struct s_Balle balle, s_Balle;
+struct s_Balle
+{
+    SDL_Rect ballePos;
+    float angle;
+    SDL_Texture *image;
+    bool collision;
+};
+
+balle nouvelle_balle(SDL_Texture *image, float angle, SDL_Rect persoPos);
+void incrementer_balle(balle *b, int vitesse);
+void afficher_balle(SDL_Renderer *renderer, balle b);
+