Merge branch 'render'

travail_de_groupe/jeu_appren_par_renfo/.vscode/settings.json

+{
+    "files.associations": {
+        "qlearn.h": "c"
+    }
+}
\ No newline at end of file

travail_de_groupe/jeu_appren_par_renfo/src/ball.c

 #include "ball.h"
 
 ball_t ball;
+int whoScored;
 int trajectoireAntoine[NUMBERPOINT_TRAJEC][2];
 
 void initBall()
 {
-    ball.x = (rand()%(MAP_WIDTH/2)) * BLOCK_SIZE + BLOCK_SIZE;
-    ball.y = (rand()% (MAP_HEIGHT - 2)) * BLOCK_SIZE + BLOCK_SIZE;
+    ball.x = player.x + player.w / 2;
+    ball.y = player.y;
     ball.z = player.h / BLOCK_SIZE;
     ball.h = 0.5 * BLOCK_SIZE;
     ball.w = 0.5 * BLOCK_SIZE;
     ball.isHit = 0;
     ball.angle = -pi;
     ball.speed = 0;
+    landingPointEnnemyIsFind = 0;
+    landingPointPlayerIsFind = 0;
 }
 //ball_t ball;
 int trajectoireAntoine[NUMBERPOINT_TRAJEC][2];
@@ -134,14 +137,27 @@ void updateBall()
     if (ball.isHit)
     {
         // landingPoint est déjà / BLOCK_SIZE de base
-        ball.z = lagrangeInterpolation(ball.x / BLOCK_SIZE, lastHitPoint[0] / BLOCK_SIZE, lastHitPoint[1] / BLOCK_SIZE, 15, 2 * player.h / BLOCK_SIZE, landingPoint[0], 0);
+        if (ball.isTravelingTo == AI){
+            ball.z = lagrangeInterpolation(ball.x / BLOCK_SIZE, lastHitPointPlayerX / BLOCK_SIZE, lastHitPointPlayerY / BLOCK_SIZE, 15, 2 * player.h / BLOCK_SIZE, landingPointPlayerX, 0);
+        }
+        else if (ball.isTravelingTo == PLAYER){
+            ball.z = lagrangeInterpolation(ball.x / BLOCK_SIZE, lastHitPointEnnemyX / BLOCK_SIZE, lastHitPointEnnemyY / BLOCK_SIZE, 15, 2 * ennemy.h / BLOCK_SIZE, landingPointEnnemyX, 0);
+        }
     }
-
-    if ((int)ball.z == 0)
+    if (ball.z < 0)
     {
-        ball.x = 0;
-        ball.y = 0;
+        if (ball.x/BLOCK_SIZE < MAP_WIDTH/2){
+            whoScored = AI;
+        }
+        else {
+            whoScored = PLAYER;
+        }
         ball.z = 0;
         ball.speed = 0;
+        //initBall();
+    }
+    else {
+        whoScored = NONE;
     }
+
 }

travail_de_groupe/jeu_appren_par_renfo/src/ball.h

@@ -15,6 +15,7 @@
 
 #define PLAYER 0
 #define AI 1
+#define NONE 2
 
 typedef enum
 {
@@ -43,6 +44,7 @@ typedef struct point{
 
 //extern ball_t ball;
 extern int trajectoireAntoine[NUMBERPOINT_TRAJEC][2];
+extern int whoScored;
 
 void initBall();
 float defineAngle(int, int, int, int);

travail_de_groupe/jeu_appren_par_renfo/src/ennemy.c

 #include "player.h"
 
+int landingPointEnnemyX;
+int landingPointEnnemyY;
+
+int lastHitPointEnnemyX;
+int lastHitPointEnnemyY = 0;
+
+int landingPointEnnemyIsFind = 0;
+
 int angleF;
 int angleH;
 int ennemyZone;
@@ -22,12 +30,12 @@ void manageEnnemyMovement()
 {
     if (ball.isTravelingTo == AI)
     {
-        angleF = defineAngleF(lastHitPoint[0], lastHitPoint[1], landingPoint[0], landingPoint[1]);
+        angleF = defineAngleF(lastHitPointPlayerX, lastHitPointPlayerY, landingPointPlayerX, landingPointPlayerY);
         angleF = converterIntoAngleF(angleF);
-        angleH = defineAngleH(lastHitPoint[0], landingPoint[0]);
+        angleH = defineAngleH(lastHitPointPlayerX, landingPointPlayerX);
         angleH = converterIntoAngleH(angleH);
         ennemyZone = convertIntoZone(ennemy.x, ennemy.y);
-        canonZone = convertIntoZone(lastHitPoint[0], lastHitPoint[1]);
+        canonZone = convertIntoZone(lastHitPointPlayerX, lastHitPointPlayerY);
         action = takeAction(ennemy.x, ennemy.y, Q, canonZone, angleH, angleF, 1);
         while (ennemyHasMoved == 0)
         {
@@ -90,7 +98,42 @@ void manageEnnemyMovement()
     }
 }
 
-void manageEnnemy()
-{
+int generatelandingPointEnnemy(){
+
+    int randomPointX = rand() % ((MAP_WIDTH-1)/2);
+
+    landingPointEnnemyIsFind = 1;
+    landingPointPlayerIsFind = 0;
+
+    return randomPointX;
+}
+
+
+void ennemyHitBall(){
+    if (sqrt(pow(ennemy.x - ball.x, 2) + pow(ennemy.y - ball.y, 2)) / BLOCK_SIZE < HIT_RANGE)
+    {
+        if (ball.isTravelingTo == AI)
+        {
+            
+                //cherche et trouve point de chute, UNE SEULE FOIS!
+            if(landingPointEnnemyIsFind == 0){
+                landingPointEnnemyX = generatelandingPointEnnemy();
+                ball.isTravelingTo = PLAYER;
+                ball.angle = ennemy.angle;
+                ball.speed = 4 * HIT_FORCE;
+                ball.isHit = 1;
+                ball.z = ball.z;
+                lastHitPointEnnemyX = ball.x;
+                lastHitPointEnnemyY = player.h;
+                }
+
+        }
+    }
+}
+
+void manageEnnemy(){
+
     manageEnnemyMovement();
+
+    ennemyHitBall();
 }
\ No newline at end of file

travail_de_groupe/jeu_appren_par_renfo/src/ennemy.h

@@ -8,7 +8,13 @@
 #include "qlearn.h"
 
 
+extern int landingPointEnnemyX;
+extern int landingPointEnnemyY;
 
+extern int lastHitPointEnnemyX;
+extern int lastHitPointEnnemyY;
+
+extern int landingPointEnnemyIsFind;
 
 void initEnnemy();
 void manageEnnemy();

travail_de_groupe/jeu_appren_par_renfo/src/gest_event.c

@@ -68,11 +68,11 @@ void gestGame()
             }
             if (event.motion.yrel > 0)
             {
-                player.viewAngle -= 1;
+                player.viewAngle -= 0.05 * RD;
             }
             if (event.motion.yrel < 0)
             {
-                player.viewAngle += 1;
+                player.viewAngle += 0.05 * RD;
             }
             player.deltax = cos(player.angle);
             player.deltay = sin(player.angle);
@@ -118,7 +118,8 @@ void gestGame()
 
             case SDLK_b:
                 initBall();
-                landingPointIsFind = 0;
+                landingPointPlayerIsFind = 0;
+                landingPointEnnemyIsFind = 0;
                 break;
 
             default:
@@ -151,21 +152,20 @@ void gestGame()
         case SDL_MOUSEBUTTONDOWN:
             if (event.button.button == SDL_BUTTON_LEFT)
             {
-                if (player.isHitting)
-                {
-                    player.isHitting = 0;
-                }
-                else
-                {
-                    player.isHitting = 1;
-                }
+                player.isHoldingClick = 1;
+                player.startHitTimer = timer;
+                player.startHitBool = 0;
             }
             break;
 
         case SDL_MOUSEBUTTONUP:
+
             if (event.button.button == SDL_BUTTON_LEFT)
             {
-                player.isHitting = 0;
+                player.endHitTimer = timer;
+                player.startHitBool = 1;
+                player.hitIntensity = (player.endHitTimer - player.startHitTimer) / 200;
+                player.isHoldingClick = 0;
             }
             break;
 

travail_de_groupe/jeu_appren_par_renfo/src/player.c

@@ -3,9 +3,16 @@
 player_t player;
 player_t ennemy;
 
-int *landingPoint;
-int *lastHitPoint;
-int landingPointIsFind = 0;
+int landingPointPlayerX;
+int landingPointPlayerY = 0;
+
+int lastHitPointPlayerX;
+int lastHitPointPlayerY;
+
+int rxWall, ryWall;
+float distanceWall;
+
+int landingPointPlayerIsFind = 0;
 
 void initPlayer()
 {
@@ -21,84 +28,65 @@ void initPlayer()
     ennemy.angle = -pi;
     player.speed = 100;
     player.isMoving = 0;
-    player.HPMax = 3;
-    player.currentHP = player.HPMax;
-    player.coins = 0;
     player.angle = 0;
     player.deltax = 1;
     player.deltay = 0;
     player.viewAngle = 0;
 }
 
-int *generateLandingPoint(int rxWall)
+int generatelandingPointPlayer(int rxWall, float hitIntensity)
 {
-    int *landingPoint = malloc(sizeof(int) * 2);
 
-    int randomPointX = MAP_WIDTH / 2 + 1 + rand() % (rxWall / BLOCK_SIZE - (MAP_WIDTH / 2));
-    int randomPointY = -1;
+    int randomPointX = MAP_WIDTH/2 + hitIntensity * 5;
 
-    landingPoint[0] = randomPointX;
-    landingPoint[1] = randomPointY / BLOCK_SIZE;
-    landingPointIsFind = 1;
-
-    return landingPoint;
-}
+    landingPointPlayerIsFind = 1;
+    landingPointEnnemyIsFind = 0;
 
-int *allocLastHitPoint()
-{
-    int *lastHitPoint = (int *)malloc(sizeof(int) * 2);
-    lastHitPoint[0] = 0;
-    lastHitPoint[1] = 0;
-    return lastHitPoint;
-}
-
-void freeIntList(int *list)
-{
-    if (list != NULL)
-    {
-        free(list);
-    }
+    return randomPointX;
 }
 
 void hitBall()
 {
     if (sqrt(pow(player.x - ball.x, 2) + pow(player.y - ball.y, 2)) / BLOCK_SIZE < HIT_RANGE)
     {
-        int rxWall, ryWall;
-        float distanceWall;
 
         int rxNet, ryNet;
         float distanceNet;
-        if (player.isHitting)
+        if (player.startHitBool)
         {
-            castSingleRay(player.angle, &distanceWall, &distanceNet, &rxWall, &ryWall, &rxNet, &ryNet);
-            if (rxWall > MAP_WIDTH / 2)
+        castSingleRay(player.angle, &distanceWall, &distanceNet, &rxWall, &ryWall, &rxNet, &ryNet);
+            // printf("hit\n");
+            if (rxWall > MAP_WIDTH/2)
             {
 
-                freeIntList(lastHitPoint);
-                lastHitPoint = allocLastHitPoint();
+                //cherche et trouve point de chute, UNE SEULE FOIS!
+                if(landingPointPlayerIsFind == 0){
 
-                // cherche et trouve point de chute, UNE SEULE FOIS!
-                if (landingPointIsFind == 0)
-                {
-                    freeIntList(landingPoint);
-                    landingPoint = generateLandingPoint(rxWall);
-                }
+                    landingPointPlayerX = generatelandingPointPlayer(rxWall, player.hitIntensity);
 
-                lastHitPoint[0] = ball.x;
-                lastHitPoint[1] = player.h;
+                    lastHitPointPlayerX = ball.x;
+                    lastHitPointPlayerY = player.h;
+
+                    ball.angle = player.angle;
+                    ball.speed = player.hitIntensity * 5;
+                   // ball.z = player.h;
+                    ball.isHit = 1;
+                    ball.isTravelingTo = AI;
+
+                    player.startHitBool = 0;
+                }
 
-                ball.angle = player.angle;
-                ball.speed = 2 * HIT_FORCE;
-                ball.z = player.h;
-                ball.isHit = 1;
-                ball.isTravelingTo = AI;
             }
+            // printf("valid hit\n");
+        }
+        else
+        {
+            // printf("unvalid hit\n");
         }
     }
+    //}
 }
 
-
 void manageMovement()
 {
     // z : keys[2] : avance
@@ -109,8 +97,7 @@ void manageMovement()
     float y_increment = (Keys[0] - Keys[2]) * player.deltay + (Keys[1] - Keys[3]) * cos(player.angle);
     float newpos_x = (player.x + x_increment * MOVEMENT_SPEED) / BLOCK_SIZE;
     float newpos_y = (player.y + y_increment * MOVEMENT_SPEED) / BLOCK_SIZE;
-    int widthColli = player.w / (3 * BLOCK_SIZE);
-    if (newpos_x > widthColli && newpos_x < MAP_WIDTH - widthColli && newpos_y > widthColli && newpos_y < MAP_HEIGHT - widthColli)
+    if (newpos_x >= 0 && newpos_x < MAP_WIDTH && newpos_y >= 0 && newpos_y < MAP_HEIGHT)
     {
         if (map[(int)newpos_y][(int)newpos_x] != 1)
         {
@@ -124,4 +111,6 @@ void managePlayer()
 {
     manageMovement();
     hitBall();
+    updateBall();
+    player.hitIntensityTimer = timer - player.startHitTimer;
 }
\ No newline at end of file

travail_de_groupe/jeu_appren_par_renfo/src/player.h

@@ -11,8 +11,9 @@
 #define ENTITIES_RIGHT 3
 
 #define HIT_RANGE 2
-#define HIT_FORCE 10
+#define HIT_FORCE 2
 #define MOVEMENT_SPEED 10
+#define MAX_HIT_TIME 3
 
 typedef struct player
 {
@@ -23,25 +24,34 @@ typedef struct player
     int w;
     int speed;
     int isMoving;
-    int isHitting;
+    int startHitBool;
     int isHit;
     int direction;
-    int HPMax;
-    int currentHP;
-    int coins;
     float angle;
     float deltax;
     float deltay;
     float viewAngle;
+    float startHitTimer;
+    float endHitTimer;
+    float hitIntensity;
+    float hitIntensityTimer;
+    int isHoldingClick;
 } player_t;
 
 extern player_t player;
 extern player_t ennemy;
-extern int *landingPoint;
-extern int *lastHitPoint;
-extern int landingPointIsFind;
+extern int landingPointPlayerX;
+extern int landingPointPlayerY;
 
+extern int lastHitPointPlayerX;
+extern int lastHitPointPlayerY;
+extern int landingPointPlayerIsFind;
+
+extern int rxWall;
+
+int generatelandingPointPlayer(int rxWall, float hitIntensity);
 void initPlayer();
 void managePlayer();
+void freeIntList(int *list);
 
 #endif
\ No newline at end of file

travail_de_groupe/jeu_appren_par_renfo/src/render.c

 #include "render.h"
 
+float timer = 0;
+
 SDL_Window *window;
 SDL_Renderer *renderer;
 
@@ -12,7 +14,7 @@ SDL_Rect sky;
 SDL_Rect ground;
 SDL_Rect racket;
 
-int showHub = 0;
+int showHub = 1;
 
 SDL_Texture *netTexture;
 SDL_Texture *netEdgeLeftTexture;
@@ -23,6 +25,8 @@ SDL_Texture *ballTexture;
 SDL_Texture *skyTexture;
 SDL_Texture *groundTexture;
 SDL_Texture *racketTexture;
+SDL_Texture *iaScoredTexture;
+SDL_Texture *humanScoredTexture;
 
 int **rays;
 int raysListLength = 0;
@@ -795,7 +799,7 @@ void drawBall()
         rect.x = screenDimension.w / 2 + (screenDimension.w * tan(ballAngle - player.angle)) * sqrt(3) * 0.5;
         rect.w = (ballWidth * screenDimension.w) / (2 * ballDistance / BLOCK_SIZE);
         rect.h = (ballHeight * screenDimension.h) / (2 * ballDistance / BLOCK_SIZE);
-        rect.y = (3 * screenDimension.h / 4 + player.viewAngle) - 2 * tan(ballViewAngle) * ballDistance;
+        rect.y = (2.5 * screenDimension.h / 4 + player.viewAngle) - 2 * tan(ballViewAngle) * ballDistance;
 
         destRect.x = 32 * (SDL_GetTicks() / 150 % 4);
         destRect.y = 0;
@@ -808,22 +812,29 @@ void drawBall()
 
 void drawSkyAndGround()
 {
-    destRect.x = ((int)((player.angle + pi) * RD + player.x / BLOCK_SIZE));
-    destRect.y = 0;
-    destRect.w = 100;
-    destRect.h = 128 / 2;
 
     rect.x = 0;
     rect.y = screenDimension.h / 2 + player.viewAngle;
     rect.h = screenDimension.h - rect.y;
     rect.w = screenDimension.w;
-    SDL_RenderCopy(renderer, groundTexture, &destRect, &rect);
 
+    
+    SDL_RenderCopy(renderer, groundTexture, NULL, &rect);
+
+    
     sky.x = 0;
     sky.y = 0;
     sky.w = screenDimension.w;
     sky.h = screenDimension.h / 2 + player.viewAngle;
 
+    destRect.x = 500 + (((player.angle + pi) * RD + player.x / BLOCK_SIZE));
+    if (player.angle > pi){
+        destRect.x = 500 + (((player.angle - pi) * RD + player.x / BLOCK_SIZE));
+    }
+    destRect.y =0;
+    destRect.w = 100;
+    destRect.h = 128;
+    
     SDL_RenderCopy(renderer, skyTexture, &destRect, &sky);
 
     SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
@@ -831,7 +842,14 @@ void drawSkyAndGround()
 
 void drawRacket()
 {
-    // todo
+    destRect.x = 0;
+    destRect.y = 0;
+    destRect.w = 64;
+    destRect.h = 32;
+    if (player.isHoldingClick){
+        destRect.x = 64 * ((int)(player.hitIntensityTimer/100) % 4);
+    }
+    SDL_RenderCopy(renderer, racketTexture, &destRect, NULL);
 }
 
 void drawMap2D(int map[][MAP_WIDTH])
@@ -894,10 +912,22 @@ void drawMap2D(int map[][MAP_WIDTH])
     SDL_RenderFillRect(renderer, &rect);
 
     // draw landing point
-    if (landingPointIsFind == 1)
+    if (landingPointPlayerIsFind == 1)
+    {
+        SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);
+        rect.x = landingPointPlayerX * CELL_SIZE;
+        rect.y = CELL_SIZE;
+        rect.h = (MAP_HEIGHT - 2) * CELL_SIZE;
+        rect.w = 3;
+        SDL_RenderFillRect(renderer, &rect);
+        // reset taille cellule
+        rect.h = CELL_SIZE;
+        rect.w = CELL_SIZE;
+    }
+    if (landingPointEnnemyIsFind == 1)
     {
         SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);
-        rect.x = landingPoint[0] * CELL_SIZE;
+        rect.x = landingPointEnnemyX * CELL_SIZE;
         rect.y = CELL_SIZE;
         rect.h = (MAP_HEIGHT - 2) * CELL_SIZE;
         rect.w = 3;
@@ -930,6 +960,16 @@ void drawString(char *str, int x, int y, int w, int h, int r, int g, int b, int
     SDL_DestroyTexture(texture);
 }
 
+void drawHitIntensity(){
+    SDL_SetRenderDrawColor(renderer, 255, 0, 0, 255);
+    rect.w = screenDimension.w/20;
+    rect.x = screenDimension.w - rect.w;
+    //printf("%f\n", player.hitIntensityTimer);
+    rect.h = 2 * screenDimension.h/2 * ( player.hitIntensityTimer/1000);
+    rect.y = 3 * screenDimension.h/4 - rect.h;
+    SDL_RenderFillRect(renderer, &rect);
+}
+
 void drawFPS()
 {
     char str[10];
@@ -985,6 +1025,25 @@ void drawHub()
     drawInfosBall();
 }
 
+void drawWhoScored(){
+    switch (whoScored)
+    {
+        case NONE:
+            break;
+
+        case AI:
+            SDL_RenderCopy(renderer, iaScoredTexture, NULL, NULL);
+            break;
+
+        case PLAYER:
+            SDL_RenderCopy(renderer, humanScoredTexture, NULL, NULL);
+            break;
+
+        default:
+            break;
+    }
+}
+
 void drawGame()
 {
     SDL_RenderClear(renderer);
@@ -993,28 +1052,33 @@ void drawGame()
     if (ball.x < MAP_WIDTH * BLOCK_SIZE / 2)
     {
         drawVerticalWalls();
-        drawEnnemy();
         drawHorizentalWalls();
+        drawEnnemy();
         drawVerticalNet();
         drawBall();
     }
     else
     {
         drawVerticalWalls();
-        drawEnnemy();
         drawHorizentalWalls();
+        drawEnnemy();
         // todo bonus : draw point de chute de la balle
         drawBall();
         drawVerticalNet();
     }
     drawMap2D(map);
     drawRacket();
+    if (player.isHoldingClick){
+
+        drawHitIntensity();
+    }
     drawFPS();
     // affiche le hub
     if (showHub)
     {
         drawHub();
     }
+    drawWhoScored();
 
     SDL_RenderPresent(renderer);
 }
@@ -1033,6 +1097,8 @@ void mainLoop()
     skyTexture = loadTexture("Res/sky.png");
     groundTexture = loadTexture("Res/ground.png");
     racketTexture = loadTexture("Res/racket.png");
+    iaScoredTexture = loadTexture("Res/iascored.png");
+    humanScoredTexture = loadTexture("Res/humanscored.png");
 
     ray1 = malloc(sizeof(int) * 2);
     ray2 = malloc(sizeof(int) * 2);
@@ -1055,6 +1121,7 @@ void mainLoop()
         if (delta > 1000 / FPS_TO_GET)
         {
             fps = 1000 / delta;
+            timer += delta;
             b = a;
             switch (game_state)
             {

travail_de_groupe/jeu_appren_par_renfo/src/render.h

@@ -35,8 +35,7 @@ extern SDL_Window *window;
 extern SDL_Renderer *renderer;
 extern SDL_DisplayMode screenDimension;
 
-extern int *ray1;
-extern int *ray2;
+extern float timer;
 
 extern int showHub;