BrainBlast/services/game/score-manager.js

const args = process.argv;

// Vérification si un paramètre est passé, si c'est le cas c'est qu'on fournis un fichier de score pour reprendre le jeu la ou il était 
if (args[2] !== undefined){
    global.ScoreFile = args[2]
}else{
    global.ScoreFile = "XXX.json"
}

const fs = require('fs');
const path = require('path');
const mqtt = require('mqtt');

// Fonction pour générer un nom de fichier unique
function generateUniqueFileName(baseName) {
    const now = new Date();
    const timestamp = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}_${String(now.getHours()).padStart(2, '0')}H${String(now.getMinutes()).padStart(2, '0')}`;
    return `${baseName}_${timestamp}.json`;
}

// Chemin vers le dossier "score" et le fichier
global.scoreDir = path.join(__dirname, 'score');
global.filePath = path.join(scoreDir, ScoreFile); // Remplace "XX.json" par le nom de ton fichier JSON

// Vérifie si le dossier "score" existe, sinon le crée
if (!fs.existsSync(scoreDir)) {
    fs.mkdirSync(scoreDir, { recursive: true });
}

// Vérifie si le fichier existe dans le dossier "score"
fs.access(filePath, fs.constants.F_OK, (err) => {
    if (!err) {
        // Le fichier existe, on le lit et on le parse en JSON
        fs.readFile(filePath, 'utf8', (err, data) => {
            if (err) {
                console.error("Erreur de lecture du fichier :", err);
                return;
            }
            try {
                global.jsonData = JSON.parse(data);
                console.log("Propriétés importées depuis le fichier JSON :");
            } catch (parseErr) {
                console.error("Erreur de parsing JSON :", parseErr);
            }
        });
    } else {
        // Le fichier n'existe pas, on en crée un nouveau avec un nom unique dans "score"
        const newFileName = generateUniqueFileName('Score');
        const newFilePath = path.join(scoreDir, newFileName);
        const initialContent = {
            "TEAM": {
                "Red": {
                  "Name": "XXX",
                  "TotalScore": 0,
                  "RoundScore": 0,
                  "Penality": 0,
                  "MasterPoint": 0
                },
                "Blue": {
                  "Name": "XXX",
                  "TotalScore": 0,
                  "RoundScore": 0,
                  "Penality": 0,
                  "MasterPoint": 0
                },
                "Yellow": {
                  "Name": "XXX",
                  "TotalScore": 0,
                  "RoundScore": 0,
                  "Penality": 0,
                  "MasterPoint": 0
                },
                "Green": {
                  "Name": "XXX",
                  "TotalScore": 0,
                  "RoundScore": 0,
                  "Penality": 0,
                  "MasterPoint": 0
                }
            }
        };
        
        fs.writeFile(newFilePath, JSON.stringify(initialContent, null, 2), (err) => {
            if (err) {
                console.error("Erreur de création du fichier :", err);
                return;
            }
            console.log(`Fichier JSON créé avec succès : ${newFilePath}`);
            // Mettre à jour ScoreFile et filePath

            // Charger les données initiales si nécessaire
            global.jsonData = initialContent;
            global.filePath = newFilePath
        });
    }
});

// Fonction pour mettre à jour le score d'une équipe
function updateTeamTotalScore(teamColor, points) {
    fs.readFile(filePath, 'utf8', (err, data) => {
        if (err) {
            console.error("Erreur de lecture du fichier :", err);
            return;
        }
        try {
            const jsonData = JSON.parse(data);
            // Vérifier si l'équipe existe
            if (!jsonData.TEAM.hasOwnProperty(teamColor)) {
                console.error(`L'équipe ${teamColor} n'existe pas.`);
                return;
            }  
            
            const change = parseInt(points, 10);
             
            // Mettre à jour le score
            jsonData.TEAM[teamColor].TotalScore += points;
            console.log(`Le score total pour l'équipe ${teamColor} est de ${jsonData.TEAM[teamColor].TotalScore} points !`)
            // Enregistrer les modifications dans le fichier
            client.publish(mqttScoreTopic, JSON.stringify(jsonData));
            fs.writeFile(filePath, JSON.stringify(jsonData, null, 2), (err) => {
                if (err) {
                    console.error("Erreur lors de l'écriture du fichier :", err);
                } else {
                    console.log(`Le score total de l'équipe ${teamColor} a été mis à jour avec succès dans le fichier json !`);
                }
            });
        } catch (parseErr) {
            console.error("Erreur de parsing JSON :", parseErr);
        }
    });
}


// Lecture du fichier de configuration
const config = JSON.parse(fs.readFileSync('\services\\config\\config_game.json', 'utf8'));

// Extraction des informations de config
const { services: { score: { MQTTconfig: { mqttHost, mqttScoreTopic, mqttScoreChangeTopic } } } } = config;
console.log(mqttScoreChangeTopic)
// Connexion au broker MQTT
const client = mqtt.connect(mqttHost);

client.on('connect', () => {
    console.log(`Connecté au broker MQTT à ${mqttHost}`);

    client.subscribe(mqttScoreChangeTopic, (err) => {
        if (err) console.error('[ERROR] impossible de souscrire au topic de gestion du score total');
        else console.log(`[INFO] Souscription réalisée avec succès au topic ${mqttScoreChangeTopic}]`);
    });

});

// Gestion des messages entrants
client.on('message', (topic, message) => {
    let payload;
    let process;
    let Team;
    let Action;

    try {
        // Analyse du message reçu
        payload = JSON.parse(message.toString());
    } catch (e) {
        console.error(`[ERROR] Invalid JSON message received on topic ${topic}: ${message.toString()}`);
        return;
    }
    // Vérifie que le payload est bien un objet
    if (payload && typeof payload === 'object') {
        // Extraire la clé (la couleur) et la valeur associée
        Team = Object.keys(payload)[0]; // La première (et unique) clé
        Action = payload[Team];         // La valeur associée
        //console.log(`Team: ${Team}, Action: ${Action}`);
        process = true;
    } else {
        console.error(typeof payload);
        process = false;
    }

    if (process === true){
        let currentScore = 0;
        let change = 0 ;
        switch (Team){
            case "Red":
                change = parseInt(Action, 10); // Convertit 'action' en entier
                if (!isNaN(change)) {
                    updateTeamTotalScore("Red", change)
                } else {
                    console.error(`Action invalide : ${action}`);
                }
                break;
            case "Blue":
                change = parseInt(Action, 10); // Convertit 'action' en entier
                if (!isNaN(change)) {
                    updateTeamTotalScore("Blue", change)
                } else {
                    console.error(`Action invalide : ${action}`);
                }
                break;
            case "Green":
                change = parseInt(Action, 10); // Convertit 'action' en entier
                if (!isNaN(change)) {
                    updateTeamTotalScore("Green", change)
                } else {
                    console.error(`Action invalide : ${action}`);
                }
                break;
            case "Yellow":
                change = parseInt(Action, 10); // Convertit 'action' en entier
                if (!isNaN(change)) {
                    updateTeamTotalScore("Yellow", change)
                } else {
                    console.error(`Action invalide : ${action}`);
                }
                break;
        }
    }

});

(async () => {
    while (true) {
      console.log("Boucle en arrière-plan");
  
      await new Promise((resolve) => setTimeout(resolve, 2000)); // Pause de 2 secondes
      client.publish(mqttScoreTopic, JSON.stringify(global.jsonData));
    }
  })();

client.on('error', (error) => {
    console.error('Erreur de connexion au broker MQTT:', error.message);
});