Browse Source

Fix #21 : Découpage du dictionnaire par longueur et par initiale

merge-requests/9/head
JonathanMM 4 months ago
parent
commit
6826a1c28f
  1. 4
      .gitignore
  2. 451277
      data/mots.txt
  3. 18
      docs/MettreAJourLeDictionnaire.md
  4. 6
      ts/dictionnaire.ts
  5. 12
      ts/gestionnaire.ts
  6. 4
      ts/input.ts
  7. 299728
      ts/mots/listeMotsProposables.ts
  8. 2
      tsconfig.json
  9. 57
      utils/nettoyage.js

4
.gitignore vendored

@ -1,7 +1,9 @@
config/
data/
data/*
!data/mots.txt
js/
mots/**
node_modules/
ts/mots/listeMotsATrouver.ts
ts/mots/listeMotsProposables.*
cron.prod.sh

451277
data/mots.txt

File diff suppressed because it is too large Load Diff

18
docs/MettreAJourLeDictionnaire.md

@ -0,0 +1,18 @@
# Mettre à jour le dictionnaire
Si vous souhaitez mettre à jour le dictionnaire, ou y ajouter des mots, il faut modifier le fichier data/mots.txt. Ce fichier comporte un mot par ligne, et sert de base pour la génération des autres fichiers.
Pour générer les fichiers listeMotsProposables, qui servent de dictionnaire, il faut appeler la commande suivante, depuis la racine de l'instance :
```sh
node utils/nettoyage.js
```
Ce script va vérifier la liste des mots, ne garder que les mots acceptés dans les règles, les formater correctement (les mettre en majuscule, et enlevé les accents), puis les découper par longueur et par initiale, dans les fichiers ts/mots/listeMotsProposables.\*.
Liste des règles suivi par les mots :
- Le mot n'est pas un nom propre (qui commence par une majuscule dans le fichier mots.txt)
- Le mot est entre 6 et 9 lettres
- Le mot ne commence pas par une lettre rare, à savoir : K, Q, W, X, Y, Z
- Le mot ne contient pas d'espace, d'apostrophe ou de trait d'union

6
ts/dictionnaire.ts

@ -1,4 +1,3 @@
import ListeMotsProposables from "./mots/listeMotsProposables";
export default class Dictionnaire {
public constructor() {}
@ -26,9 +25,10 @@ export default class Dictionnaire {
return btoa(idPartie + "-" + datePartieStr);
}
public static estMotValide(mot: string): boolean {
public static async estMotValide(mot: string, premiereLettre: string, longueur: number): Promise<boolean> {
mot = this.nettoyerMot(mot);
return mot.length >= 6 && mot.length <= 9 && ListeMotsProposables.Dictionnaire.includes(mot);
let ListeMotsProposables = await import("./mots/listeMotsProposables." + longueur + "." + premiereLettre);
return mot.length >= 6 && mot.length <= 9 && ListeMotsProposables.default.Dictionnaire.includes(mot);
}
public static nettoyerMot(mot: string): string {

12
ts/gestionnaire.ts

@ -68,14 +68,14 @@ export default class Gestionnaire {
this._configurationPanel = new ConfigurationPanel(this._panelManager, this._audioPanel, this._themeManager);
this.choisirMot(this._idPartieEnCours, this._datePartieEnCours)
.then((mot) => {
.then(async (mot) => {
this._motATrouver = mot;
this._input = new Input(this, this._config, this._motATrouver.length, this._motATrouver[0]);
this._panelManager.setInput(this._input);
this._grille = new Grille(this._motATrouver.length, this._maxNbPropositions, this._motATrouver[0], this._audioPanel);
this._configurationPanel.setInput(this._input);
this._compositionMotATrouver = this.decompose(this._motATrouver);
this.chargerPropositions(partieEnCours.propositions);
await this.chargerPropositions(partieEnCours.propositions);
})
.catch((raison) => NotificationMessage.ajouterNotification("Aucun mot n'a été trouvé pour aujourd'hui"));
@ -111,10 +111,10 @@ export default class Gestionnaire {
return new PartieEnCours();
}
private chargerPropositions(propositions: Array<string> | undefined): void {
private async chargerPropositions(propositions: Array<string> | undefined): Promise<void> {
if (!propositions || propositions.length === 0) return;
for (let mot of propositions) {
this.verifierMot(mot, true);
await this.verifierMot(mot, true);
}
}
@ -165,7 +165,7 @@ export default class Gestionnaire {
return composition;
}
public verifierMot(mot: string, chargementPartie: boolean = false): boolean {
public async verifierMot(mot: string, chargementPartie: boolean = false): Promise<boolean> {
mot = Dictionnaire.nettoyerMot(mot);
//console.debug(mot + " => " + (Dictionnaire.estMotValide(mot) ? "Oui" : "non"));
if (mot.length !== this._motATrouver.length) {
@ -176,7 +176,7 @@ export default class Gestionnaire {
NotificationMessage.ajouterNotification("Le mot proposé doit commencer par la même lettre que le mot recherché");
return false;
}
if (!Dictionnaire.estMotValide(mot)) {
if (!(await Dictionnaire.estMotValide(mot, this._motATrouver[0], this._motATrouver.length))) {
NotificationMessage.ajouterNotification("Ce mot n'est pas dans notre dictionnaire");
return false;
}

4
ts/input.ts

@ -157,10 +157,10 @@ export default class Input {
this._gestionnaire.actualiserAffichage(this._motSaisi);
}
private validerMot(): void {
private async validerMot(): Promise<void> {
if (this._estBloque) return;
let mot = this._motSaisi;
let isMotValide = this._gestionnaire.verifierMot(mot);
let isMotValide = await this._gestionnaire.verifierMot(mot);
if (isMotValide) this._motSaisi = "";
}

299728
ts/mots/listeMotsProposables.ts

File diff suppressed because it is too large Load Diff

2
tsconfig.json

@ -59,6 +59,6 @@
"moduleResolution": "node"
},
"include": ["ts/*.ts", "type/*"]
"include": ["ts/*.ts", "ts/mots/listeMotsProposables.*.*.ts", "type/*"]
}

57
utils/nettoyage.js

@ -5,6 +5,29 @@
*/
var fs = require("fs");
function ecrireDictionnaire(dictionnaire, suffixeNom) {
console.log("Écriture du dictionnaire " + (suffixeNom !== undefined ? suffixeNom : "général"));
let contenu = "export default class ListeMotsProposables {\n";
contenu += "public static readonly Dictionnaire: Array<string> = [\n";
contenu += dictionnaire
.map(function (mot) {
return '"' + mot.toUpperCase() + '",';
})
.join("\n");
contenu += "\n];";
contenu += "\n}";
let nomFichier = "ts/mots/listeMotsProposables";
if (suffixeNom !== undefined) nomFichier += suffixeNom;
nomFichier += ".ts";
fs.writeFile(nomFichier, contenu, function (err) {
if (err) {
console.error(err);
return;
}
//file written successfully
});
}
fs.readFile("data/mots.txt", "UTF8", function (erreur, contenu) {
//console.log(erreur);
var dictionnaire = contenu
@ -35,19 +58,25 @@ fs.readFile("data/mots.txt", "UTF8", function (erreur, contenu) {
.filter(function (elem, index, self) {
return index === self.indexOf(elem);
});
dictionnaire.sort();
contenu = "public static readonly Dictionnaire: Array<string> = [\n";
contenu += dictionnaire
.map(function (mot) {
return '"' + mot.toUpperCase() + '",';
})
.join("\n");
contenu += "\n];";
fs.writeFile("data/motsNettoyes.txt", contenu, function (err) {
if (err) {
console.error(err);
return;
}
//file written successfully
dictionnaire.sort((a, b) => {
if (a.length < b.length) return -1;
if (a.length > b.length) return 1;
if (a < b) return -1;
if (a > b) return 1;
return 0;
});
console.log("Longueur du dictionnaire : " + dictionnaire.length);
ecrireDictionnaire(dictionnaire);
let longueurs = [6, 7, 8, 9];
let initialesPossibles = ["A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "L", "M", "N", "O", "P", "R", "S", "T", "U", "V"];
for (let longueur of longueurs) {
for (let initiale of initialesPossibles) {
let dicoFiltre = dictionnaire.filter((mot) => mot.length === longueur && mot.toUpperCase().startsWith(initiale));
console.log("Longueur du dictionnaire : " + dicoFiltre.length);
ecrireDictionnaire(dicoFiltre, "." + longueur + "." + initiale);
}
}
});

Loading…
Cancel
Save