TP-Awale/server/defi.c at 6b2505e2e3f85ad12d03c6626c74c2c19362a1c5 · hoverwars/TP-Awale · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
#include "events.h"

/*void handle_defi(int sock, int argc, char** argv, int pipe_write_to_p) {
    // argv[0] = "DEFI", argv[1] = pseudo_local, argv[2] = adversaire
    if (argc < 3) {
        envoyer_message(sock, "ERREUR_PROTOCOLE Commande DEFI incomplete. Usage: DEFI <adversaire>");
        return;
    }

    const char *pseudo_local = argv[1];
    const char *adversaire = argv[2];

    if (strcmp(pseudo_local, adversaire) == 0) {
        envoyer_message(sock, "ERREUR_DEFI Vous ne pouvez pas vous defier vous-meme.");
        return;
    }

    // ENVOI AU PÈRE VIA IPC : DEFI <defiante> <adversaire>
    char ipc_msg[MAX_BUFFER];
    snprintf(ipc_msg, MAX_BUFFER, "DEFI %s %s", pseudo_local, adversaire);

    envoyer_ipc(pipe_write_to_p, ipc_msg);

    printf("FIL (%s): Defi envoye au PERE pour repartition vers %s.\n", pseudo_local, adversaire);
    envoyer_message(sock, "DEFI_ENVOYE En attente de la reponse de l'adversaire...");
}*/

void handle_defi(int sock, int argc, char** argv, int pipe_write_to_p)
{
    const char *defiante = argv[1];
    const char *adversaire = argv[2];

    printf("%s %s\n", defiante, adversaire);
    int idx_defiante = trouver_index_joueur(defiante);
    int idx_adversaire = trouver_index_joueur(adversaire);

    if (idx_adversaire == -1) {
        // Le joueur ciblé n'est pas actif
        if (idx_defiante != -1) {
            char notif[MAX_BUFFER];
            snprintf(notif, MAX_BUFFER, "ERREUR_DEFI Le joueur %s n'est pas actif.", adversaire);
            envoyer_ipc(joueurs_actifs[idx_defiante].pipe_p_to_f, notif);
        }
    } else if (idx_defiante != -1 && joueurs_actifs[idx_defiante].en_partie) {
        // Le défieur est déjà en partie
        char notif[MAX_BUFFER];
        snprintf(notif, MAX_BUFFER, "ERREUR_DEFI Vous etes deja en partie.");
        envoyer_ipc(joueurs_actifs[idx_defiante].pipe_p_to_f, notif);
    } else if (joueurs_actifs[idx_adversaire].en_partie) {
        // Le joueur défié est occupé
        if (idx_defiante != -1) {
            char notif[MAX_BUFFER];
            snprintf(notif, MAX_BUFFER, "ERREUR_DEFI Le joueur %s est deja en partie.", adversaire);
            envoyer_ipc(joueurs_actifs[idx_defiante].pipe_p_to_f, notif);
        }
    } else {
        // Relayer le défi au fils de l'adversaire
        char notif[MAX_BUFFER];
        snprintf(notif, MAX_BUFFER, "DEFI_RECU %s", defiante);
        envoyer_ipc(joueurs_actifs[idx_adversaire].pipe_p_to_f, notif);
        printf("PÈRE: Défi de %s relayé à %s.\n", defiante, adversaire);
    }
}

void handle_refuse(int sock, int argc, char** argv, int pipe_write_to_p) {
    // argv[0] = "REFUSE", argv[1] = pseudo_local, argv[2] = defiante

    if (argc < 3) {
        envoyer_message(sock, "ERREUR_PROTOCOLE Commande REFUSE incomplete. Usage: REFUSE <defiante>");
        return;
    }

    const char *pseudo_local = argv[1];
    const char *defiante = argv[2];

    if (strcmp(pseudo_local, defiante) == 0) {
        envoyer_message(sock, "ERREUR_REFUSE Vous ne pouvez pas vous refuser vous-meme.");
        return;
    }

    // ENVOI AU PÈRE VIA IPC : REFUSE <défié> <defiante>
    char ipc_msg[MAX_BUFFER];
    snprintf(ipc_msg, MAX_BUFFER, "REFUSE %s %s", pseudo_local, defiante);

    envoyer_ipc(pipe_write_to_p, ipc_msg);

    printf("FIL (%s): Refus de defi envoye au PERE pour notification vers %s.\n", pseudo_local, defiante);
    envoyer_message(sock, "DEFI_REFUSE_ENVOYE Refus du defi envoye.");
}

void handle_accept(int sock, int argc, char** argv, int pipe_write_to_p) {
    // argv[0] = "ACCEPT", argv[1] = pseudo_local (défié), argv[2] = defiante (défiant)
    if (argc < 3) {
        envoyer_message(sock, "ERREUR_PROTOCOLE Commande ACCEPT incomplete. Usage: ACCEPT <defiante>");
        return;
    }

    const char *pseudo_local = argv[1];
    const char *defiante = argv[2];

    if (strcmp(pseudo_local, defiante) == 0) {
        envoyer_message(sock, "ERREUR_ACCEPT Vous ne pouvez pas accepter votre propre defi.");
        return;
    }

    // ENVOI AU PÈRE VIA IPC : ACCEPT <defie> <defiante>
    char ipc_msg[MAX_BUFFER];
    snprintf(ipc_msg, MAX_BUFFER, "ACCEPT %s %s", pseudo_local, defiante);
    envoyer_ipc(pipe_write_to_p, ipc_msg);

    // Accusé de réception côté client (le père enverra ensuite les notifications aux 2 joueurs)
    envoyer_message(sock, "DEFI_ACCEPT_ENVOYE Acceptation envoyee. En attente de synchronisation...");
}