public void AjouterSegment(clsSegmentBase segment)
{
if (segment == null)
{
throw new ArgumentNullException("segment");
}
this.m_lstSegments.Add(segment.sSegment);
this.m_lstSegments.Add(segment.sSens);
this.m_lstSegments.Add(segment.sLogotron);
this.m_lstSegments.Add(segment.sNiveau);
this.m_lstSegments.Add(segment.sEtym);
this.m_lstSegments.Add(segment.sUnicite);
this.m_lstSegments.Add(segment.sOrigine);
this.m_lstSegments.Add(segment.sFrequence);
}
public List <clsSegmentBase> ObtenirSegmentBases()
{
List <clsSegmentBase> lst = new List <clsSegmentBase>();
int iNbSegments = this.iLireNbSegments();
for (int i = 0; i <= iNbSegments - 1; i++)
{
clsSegmentBase segment = null;
if (this.bLireSegment(i, ref segment))
{
lst.Add(segment);
}
}
return(lst);
}
public clsInitTirage(clsSegmentBase segment)
{
this.lstNumSegmentDejaTires = new List <int>();
this.lstSegmentsDejaTires = new List <string>();
this.lstSensSegmentDejaTires = new List <string>();
this.lstUnicitesSegmentDejaTires = new List <string>();
if (segment == null)
{
throw new ArgumentNullException("segment");
}
this.lstNumSegmentDejaTires.Add(segment.iNumSegment);
this.lstSegmentsDejaTires.Add(segment.sSegment);
this.lstSensSegmentDejaTires.Add(segment.sSens);
if (segment.sUnicite.Length > 0)
{
this.lstUnicitesSegmentDejaTires.Add(segment.sUnicite);
}
}
public int iLireNbSegmentsUniques(
List <string> lstNiv, List <string> lstFreq,
bool bGrecoLatin, bool bNeoRigolo)
{
// Retourner la liste de segments uniques selon le sens, avec les niveaux indiqués
// (sélection du Logotron)
if (lstNiv == null)
{
throw new ArgumentNullException("lstNiv");
}
if (lstFreq == null)
{
throw new ArgumentNullException("lstFreq");
}
HashSet <string> hsSegments = new HashSet <string>();
int iNbSegments = iLireNbSegments();
for (int i = 0; i <= iNbSegments - 1; i++)
{
clsSegmentBase segment = null;
if (!bLireSegment(i, ref segment))
{
continue;
}
if (!lstNiv.Contains(segment.sNiveau))
{
continue;
}
if (!lstFreq.Contains(segment.sFrequence))
{
continue;
}
if (segment.sLogotron != clsConst.sSelectLogotron)
{
continue;
}
if ((bGrecoLatin || !bNeoRigolo) &&
segment.sOrigine == enumOrigine.sNeologismeAmusant)
{
//if (LogotronLib.clsConst.bDebug)
// Console.WriteLine("Segment non retenu : " +
// segment.sSegment + " : " + segment.sOrigine);
continue;
}
if (bGrecoLatin &&
!(segment.sOrigine == enumOrigine.sGrec ||
segment.sOrigine == enumOrigine.sLatin ||
segment.sOrigine == enumOrigine.sGrecoLatin))
{
//if (LogotronLib.clsConst.bDebug)
// Console.WriteLine("Segment non gréco-latin : " +
// segment.sSegment + " : " + segment.sOrigine);
continue;
}
string sSensSansArticle = clsBase.sSupprimerArticle(segment.sSens);
string sCleUniciteSens = sSensSansArticle;
if ((segment.sUnicite.Length > 0))
{
sCleUniciteSens = segment.sUnicite;
}
if (!hsSegments.Contains(sCleUniciteSens))
{
hsSegments.Add(sCleUniciteSens);
}
}
return(hsSegments.Count);
}
public bool bLireSegment(int iNumSegmentL, ref clsSegmentBase segment)
{
segment = null;
if (this.m_iNbColonnes <= 0)
{
if (clsConst.bDebug)
{
Debugger.Break();
}
return(false);
}
if (iNumSegmentL == clsConst.iTirageImpossible)
{
return(false);
}
segment = new clsSegmentBase();
segment.iNumSegment = iNumSegmentL;
int iNumSegment = iNumSegmentL * this.m_iNbColonnes;
segment.sSegment = this.m_lstSegments[iNumSegment + iColSegment];
if (clsConst.bDebug && segment.sSegment == null)
{
Debugger.Break();
}
//if (segment.sSegment.StartsWith("algo")) Debug.WriteLine("!");
if (this.m_iNbColonnes <= iColSens)
{
return(true);
}
segment.sSens = this.m_lstSegments[iNumSegment + iColSens];
if (clsConst.bDebug && segment.sSens == null)
{
Debugger.Break();
}
if (this.m_iNbColonnes <= iColLogotron)
{
return(true);
}
segment.sLogotron = this.m_lstSegments[iNumSegment + iColLogotron];
if (clsConst.bDebug && segment.sLogotron == null)
{
Debugger.Break();
}
if (this.m_iNbColonnes <= iColNiveau)
{
return(true);
}
segment.sNiveau = this.m_lstSegments[iNumSegment + iColNiveau];
if (clsConst.bDebug && segment.sNiveau == null)
{
Debugger.Break();
}
segment.iNiveau = int.Parse(segment.sNiveau);
if (this.m_iNbColonnes <= iColEtym)
{
return(true);
}
segment.sEtym = this.m_lstSegments[iNumSegment + iColEtym];
if (clsConst.bDebug && segment.sEtym == null)
{
Debugger.Break();
}
if (this.m_iNbColonnes <= iColUnicite)
{
return(true);
}
segment.sUnicite = this.m_lstSegments[iNumSegment + iColUnicite];
if (clsConst.bDebug && segment.sUnicite == null)
{
Debugger.Break();
}
if (this.m_iNbColonnes <= iColOrigine)
{
return(true);
}
segment.sOrigine = this.m_lstSegments[iNumSegment + iColOrigine];
if (clsConst.bDebug && segment.sOrigine == null)
{
Debugger.Break();
}
if (this.m_iNbColonnes <= iColFrequence)
{
return(true);
}
segment.sFrequence = this.m_lstSegments[iNumSegment + iColFrequence];
if (clsConst.bDebug && segment.sFrequence == null)
{
Debugger.Break();
}
string sSensSansArticle = clsBase.sSupprimerArticle(segment.sSens);
string sUniciteFinale = sSensSansArticle;
segment.sUniciteSynth = sUniciteFinale;
if (segment.sUnicite.Length > 0)
{
segment.sUniciteSynth = segment.sUnicite;
}
if (this.m_iNbColonnes <= clsConst.iNbColonnes)
{
return(true);
}
return(true);
}
public static int iTirageMotExistant(
List <string> lstNiv, List <string> lstFreq,
ref clsSegmentBase prefixe, ref clsSegmentBase suffixe)
{
// Tirer au hasard un mot du niveau demandé
// 01/05/2019 Test élision : mot0.Value.bElisionPrefixe &&
var enreg = from mot0 in m_dicoMotsExistants.ToList()
where
lstNiv.Contains(mot0.Value.sNivPrefixe) &&
lstNiv.Contains(mot0.Value.sNivSuffixe) &&
lstFreq.Contains(mot0.Value.sFreqPrefixe) &&
lstFreq.Contains(mot0.Value.sFreqSuffixe)
select mot0;
int iNbEnreg = enreg.Count();
if (iNbEnreg == 0)
{
if (clsConst.bDebug)
{
Debugger.Break();
}
m_msgDelegue.AfficherMsg(
"Aucun mot ne correspond à la sélection : Tirage impossible !");
return(clsConst.iTirageImpossible);
}
int iNbMotsExistantsFiltres = iNbEnreg;
// On tire un nombre compris entre 0 et iNbSegmentsFilres - 1 (liste filtrée)
int iNumMotExistantTire = clsUtil.iRandomiser(0, iNbMotsExistantsFiltres - 1);
var mot = enreg.ElementAtOrDefault(iNumMotExistantTire).Value;
if (mot == null)
{
if (clsConst.bDebug)
{
Debugger.Break();
}
m_msgDelegue.AfficherMsg(
"Aucun mot ne correspond à la sélection : Tirage impossible !");
return(clsConst.iTirageImpossible);
}
// Indice du mot dans la liste complète
int iNumMotExistant = mot.iNumMotExistant;
if (iNumMotExistant == 0)
{
if (clsConst.bDebug)
{
Debugger.Break();
}
m_msgDelegue.AfficherMsg(
"Aucun mot ne correspond à la sélection : Tirage impossible !");
return(clsConst.iTirageImpossible);
}
prefixe = new clsSegmentBase();
suffixe = new clsSegmentBase();
prefixe.sSegment = mot.sPrefixe;
prefixe.sLogotron = clsConst.sSelectDictionnaire;
prefixe.sNiveau = mot.sNivPrefixe;
prefixe.sSens = mot.sDefPrefixe;
prefixe.sEtym = "";
prefixe.sUnicite = mot.sUnicitePrefixe;
prefixe.sUniciteSynth = mot.sUnicitePrefixeSynth;
prefixe.sFrequence = mot.sFreqPrefixe;
// 01/05/2019
prefixe.bElision = mot.bElisionPrefixe;
prefixe.sSegmentElision = prefixe.sSegment;
if (prefixe.bElision)
{
prefixe.sSegmentElision =
prefixe.sSegment.Substring(0, prefixe.sSegment.Length - 1);
}
suffixe.sSegment = mot.sSuffixe;
suffixe.sLogotron = clsConst.sSelectDictionnaire;
suffixe.sNiveau = mot.sNivSuffixe;
suffixe.sSens = mot.sDefSuffixe;
suffixe.sEtym = "";
suffixe.sUnicite = mot.sUniciteSuffixe;
suffixe.sUniciteSynth = mot.sUniciteSuffixeSynth;
suffixe.sFrequence = mot.sFreqSuffixe;
return(iNumMotExistant);
}
public static bool bTirage(bool bComplet, string sNbPrefixesSuccessifs,
List <string> lstNiv, List <string> lstFreq,
ref string sMot, ref string sExplication,
ref string sDetail, ref List <string> lstEtymFin,
bool bGrecoLatin, bool bNeoRigolo, clsMsgDelegue msgDelegue)
{
List <string> lstEtym = new List <string>();
int iNbTiragesPrefixes = 0;
if (sNbPrefixesSuccessifs == clsConst.sHasard)
{
iNbTiragesPrefixes = clsUtil.iRandomiser(1, 5);
float rProba = 1f;
switch (iNbTiragesPrefixes)
{
case 1:
rProba = 1f; // Toujours accepté
break;
case 2:
rProba = 1 / 2f; // Une fois sur 2
//rProba = 0.1f; // Une fois sur 10
break;
case 3:
rProba = 1 / 4f; // Une fois sur 4
//rProba = 1/3f; // Une fois sur 3
//rProba = 0.05f;
break;
case 4:
rProba = 1 / 8f; // Une fois sur 8
//rProba = 1/4f; // Une fois sur 4
//rProba = 0.03f;
break;
case 5:
rProba = 1 / 16f; // Une fois sur 16
//rProba = 1/5f; // Une fois sur 5
//rProba = 0.01f;
break;
}
if (rProba < 1f)
{
float rTirage = clsUtil.rRandomiser();
if (rTirage > rProba)
{
iNbTiragesPrefixes = 1;
}
}
}
else
{
iNbTiragesPrefixes = int.Parse(sNbPrefixesSuccessifs);
}
string sPrefixesMaj = "";
string sSensPrefixesMaj = "";
string sDetailPrefixesMaj = "";
clsInitTirage itPref = new clsInitTirage();
clsGestBase.m_prefixes.MsgDelegue = msgDelegue;
clsGestBase.m_suffixes.MsgDelegue = msgDelegue;
for (int i = 0; i <= iNbTiragesPrefixes - 1; i++)
{
//if (LogotronLib.clsConst.bDebug)
// Console.WriteLine("Tirage préfixe n°" + (i + 1));
int iNumPrefixe = clsGestBase.m_prefixes.iTirageSegment(bComplet,
lstNiv, lstFreq, itPref, bGrecoLatin, bNeoRigolo);
clsSegmentBase prefixe = null;
if (!clsGestBase.m_prefixes.bLireSegment(iNumPrefixe, ref prefixe))
{
return(false);
}
string sNiveauP = prefixe.sNiveau;
string sPrefixe = prefixe.sSegment;
string sPrefixeMaj = sPrefixe.ToUpper();
string sSensPrefixeMaj2 = prefixe.sSens.ToUpper();
sSensPrefixeMaj2 = clsBase.sCompleterPrefixe(sSensPrefixeMaj2);
sPrefixesMaj += sPrefixeMaj;
sSensPrefixesMaj = sSensPrefixesMaj + " " + sSensPrefixeMaj2;
sDetailPrefixesMaj = sDetailPrefixesMaj + sPrefixeMaj + "(" + sNiveauP + ") - ";
string sEtymPrefixe = prefixe.sEtym;
if (sEtymPrefixe.Length > 0)
{
lstEtym.Add(sPrefixe + "- : " + sEtymPrefixe);
}
}
//if (LogotronLib.clsConst.bDebug) Console.WriteLine("Tirage suffixe");
int iNumSuffixe = clsGestBase.m_suffixes.iTirageSegment(bComplet,
lstNiv, lstFreq, new clsInitTirage(), bGrecoLatin, bNeoRigolo);
clsSegmentBase suffixe = null;
if (!clsGestBase.m_suffixes.bLireSegment(iNumSuffixe, ref suffixe))
{
return(false);
}
string sNiveauS = suffixe.sNiveau;
string sSuffixe = suffixe.sSegment;
string sSuffixeMaj = sSuffixe.ToUpper();
string sDetailSuffixeMaj = sSuffixeMaj + "(" + sNiveauS + ")";
string sSensSuffixeMaj = suffixe.sSens.ToUpper();
sMot = sPrefixesMaj + sSuffixeMaj;
sExplication = sSensSuffixeMaj + sSensPrefixesMaj;
sDetail = sDetailPrefixesMaj + sDetailSuffixeMaj;
string sEtymSuffixe = suffixe.sEtym;
if (sEtymSuffixe.Length > 0)
{
lstEtym.Add("-" + sSuffixe + " : " + sEtymSuffixe);
}
lstEtymFin = lstEtym;
//msgDelegue.AfficherMsg("Test MsgBox");
return(true);
}
