SAE11_2024/jeu_ia.c

#include <stdio.h>
#include <stdlib.h>
#include <graph.h>
#include <unistd.h>
#include "jeu.h"
#include "jeu_ia.h"
#include "jeu_humain.h"

/* Fonction qui permet de jouer avec l'IA */
void jouerModeIA(struct EtatJeu *etatJeu) {
    int compteurIA = 0; 
    
    while (1) {
        if (etatJeu->tourJoueur == 1) {  
            compteurIA = 0;  
            if (SourisCliquee()) {
                if (etatJeu->phase == 0) {
                    gererPlacementInitialIA(etatJeu);
                } else {
                    gererTourJoueurIA(etatJeu);
                }
                
                if (etatJeu->phase > 0 && !peutDeplacer(*etatJeu, etatJeu->tourJoueur)) {
                    afficherVictoire(etatJeu->tourJoueur == 1 ? 2 : 1);
                    while (!SourisCliquee()) {}
                    break;
                }
            }
        } else { 
            compteurIA++;
            if (compteurIA > 50) {  
                if (etatJeu->phase == 0) {
                    placementIA(etatJeu);
                } else if (etatJeu->phase == 1) {
                    deplacementIA(etatJeu);
                } else {
                    blocageIA(etatJeu);
                }
                
                if (etatJeu->phase > 0 && !peutDeplacer(*etatJeu, etatJeu->tourJoueur)) {
                    afficherVictoire(etatJeu->tourJoueur == 1 ? 2 : 1);
                    while (!SourisCliquee()) {}
                    break;
                }
            }
        }
    }
}

/* Fonction qui gère le placement initial de l'IA */
void gererPlacementInitialIA(struct EtatJeu *etatJeu) {
    int x, y, i, j;
    int largeurFenetre = 800;
    int hauteurFenetre = 600;
    int marge = 50;
    int tailleCase;
    int startX, startY;
    
    x = _X;
    y = _Y;
    
    /* Calcul de la taille de chaque case */
    tailleCase = (largeurFenetre - 2 * marge) / etatJeu->tailleGrille;
    if (tailleCase * etatJeu->tailleGrille > (hauteurFenetre - 2 * marge)) {
        tailleCase = (hauteurFenetre - 2 * marge) / etatJeu->tailleGrille;
    }
    /* Calcul de la position de départ de la grille */
    startX = (largeurFenetre - (tailleCase * etatJeu->tailleGrille)) / 2;
    startY = (hauteurFenetre - (tailleCase * etatJeu->tailleGrille)) / 2;
    
    x -= startX;
    y -= startY;
    
    i = y / tailleCase;
    j = x / tailleCase;
    
    /* Vérifie si la case est valide */
    if (i >= 0 && i < etatJeu->tailleGrille && 
        j >= 0 && j < etatJeu->tailleGrille && 
        etatJeu->grille[i][j] == 0) {
        
        etatJeu->grille[i][j] = 1;
        etatJeu->joueur1.x = j;
        etatJeu->joueur1.y = i;
        etatJeu->tourJoueur = 2;
        dessinerGrille(*etatJeu);
    }
}

/* Fonction qui gère le tour de l'IA */
void gererTourJoueurIA(struct EtatJeu *etatJeu) {
    int x, y, i, j;
    int largeurFenetre = 800;
    int hauteurFenetre = 600;
    int marge = 50;
    int tailleCase;
    int startX, startY;
    struct Position posActuelle;
    struct Position posCliquee;
    
    x = _X;
    y = _Y;
    
    /* Calcul de la taille de chaque case */
    tailleCase = (largeurFenetre - 2 * marge) / etatJeu->tailleGrille;
    if (tailleCase * etatJeu->tailleGrille > (hauteurFenetre - 2 * marge)) {
        tailleCase = (hauteurFenetre - 2 * marge) / etatJeu->tailleGrille;
    }
    /* Calcul de la position de départ de la grille */
    startX = (largeurFenetre - (tailleCase * etatJeu->tailleGrille)) / 2;
    startY = (hauteurFenetre - (tailleCase * etatJeu->tailleGrille)) / 2;
    
    x -= startX;
    y -= startY;
    
    i = y / tailleCase;
    j = x / tailleCase;
    
    /* Position actuelle du joueur 1 */
    posActuelle = etatJeu->joueur1;
    posCliquee.x = j;
    posCliquee.y = i;
    
    /* Vérifie si la case est valide */
    if (i >= 0 && i < etatJeu->tailleGrille && j >= 0 && j < etatJeu->tailleGrille) {
        if (etatJeu->phase == 1) {
            if (etatJeu->grille[i][j] == 0 && estCaseAdjacente(posActuelle, posCliquee)) {
                etatJeu->grille[etatJeu->joueur1.y][etatJeu->joueur1.x] = 0;
                etatJeu->grille[i][j] = 1;
                etatJeu->joueur1.x = j;
                etatJeu->joueur1.y = i;
                etatJeu->phase = 2;
                dessinerGrille(*etatJeu);
            }
        } else if (etatJeu->phase == 2) {
            if (etatJeu->grille[i][j] == 0) {
                etatJeu->grille[i][j] = 3;
                etatJeu->phase = 1;
                etatJeu->tourJoueur = 2;
                dessinerGrille(*etatJeu);
            }
        }
    }
}

/* Fonction qui permet de s'assurer que l'IA place son pion à un endroit valide */
void placementIA(struct EtatJeu *etatJeu) {
    int i, j;
    /* Boucle qui place le pion de l'IA à un endroit valide à l'aide de random */
    do {
        i = rand() % etatJeu->tailleGrille;
        j = rand() % etatJeu->tailleGrille;
    } while (etatJeu->grille[i][j] != 0);
    
    etatJeu->grille[i][j] = 2;
    etatJeu->joueur2.x = j;
    etatJeu->joueur2.y = i;
    etatJeu->phase = 1;
    etatJeu->tourJoueur = 1;
    dessinerGrille(*etatJeu);
}

/* Fonction qui permet à l'IA de déplacer son pion */
void deplacementIA(struct EtatJeu *etatJeu) {
    int dx, dy;
    int newX, newY;
    int trouve = 0;
    
    /* Boucle qui permet de trouver une case valide pour le déplacement */
    for(dx = -1; dx <= 1 && !trouve; dx++) {
        for(dy = -1; dy <= 1 && !trouve; dy++) {
            if(dx == 0 && dy == 0) continue;
            
            newX = etatJeu->joueur2.x + dx;
            newY = etatJeu->joueur2.y + dy;
            
            if(newX >= 0 && newX < etatJeu->tailleGrille && 
               newY >= 0 && newY < etatJeu->tailleGrille && 
               etatJeu->grille[newY][newX] == 0) {
                
                etatJeu->grille[etatJeu->joueur2.y][etatJeu->joueur2.x] = 0;
                etatJeu->grille[newY][newX] = 2;
                etatJeu->joueur2.x = newX;
                etatJeu->joueur2.y = newY;
                etatJeu->phase = 2;
                trouve = 1;
            }
        }
    }
    dessinerGrille(*etatJeu);
}

/* Fonction qui permet à l'IA de placer un pion de blocage */
void blocageIA(struct EtatJeu *etatJeu) {
    int i, j;
    
    do {
        i = rand() % etatJeu->tailleGrille;
        j = rand() % etatJeu->tailleGrille;
    } while (etatJeu->grille[i][j] != 0);
    
    etatJeu->grille[i][j] = 3;
    etatJeu->phase = 1;
    etatJeu->tourJoueur = 1;
    dessinerGrille(*etatJeu);
}