-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathcasino-beta.py
1240 lines (1093 loc) · 57.4 KB
/
casino-beta.py
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
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
############################################################################################
# casino BOT- PAR Maxime #
# Version 1.1 #
# # #
# modification 31/05/2024: #
# #
# ajout du ssl conexion securiser #
# #
# ajout d'une identification au oret de nickserv #
# #
# ajoutle fet que le bot peux ce /oper (IRCOP) si c'est votre server #
# #
# ajout de la commande !restart pour restart le bot #
# #
# ajout de la commande !demande #votre-salon pour fair rejoindre le bot sur votre salon #
# #
# ajout de la commande !addadmin pour ajouter des administrateur au bot #
# #
# ajout d'un fichier admins.txt ou son stocker les admins #
# #
# ajout de la commande !deladmin pour supprimer un administrateur au bot #
# #
# ajoute de la commande !listadmin pour voir la liste des administrateur disponible #
# #
# version 1.2 #
# #
# modification 30/09/2024: #
# #
# ajout d'une page html des stats joueur #
# #
# ajout d'une anonce sur un salon pour inviter les users a jouer sur #casino #
# #
# casino bot en python #
############################################################################################
import sys
import os
import ssl
import irc
import socket
import re
import mariadb
import signal
import time
from datetime import datetime
import random
from colorama import Fore
from dotenv import load_dotenv
from datetime import datetime, timedelta
import threading
# Définir la version du bot
version_bot = "casino BOT- PAR Maxime Version 1.2" # pour le respect de mon trvaille merci de ne pas modifier cette ligne
class Color:
PURPLE = '\033[95m'
CYAN = '\033[96m'
DARKCYAN = '\033[36m'
BLUE = '\033[94m'
GREEN = '\033[92m'
YELLOW = '\033[93m'
RED = '\033[91m'
BOLD = '\033[1m'
UNDERLINE = '\033[4m'
END = '\033[0m'
# Écriture du Pid
with open('bot.pid', 'w', encoding='utf-8') as f:
f.write(str(os.getpid()))
# Configuration de la base de données
db_host = "localhost"
db_user = "casino"
db_password = "votre-mot-de-pass"
db_name = "casino"
# Connexion à la base de données
try:
conn = mariadb.connect(
user=db_user,
password=db_password,
host=db_host,
database=db_name
)
cursor = conn.cursor()
except mariadb.Error as e:
print(f"Erreur de connexion à la base de données: {e}")
exit(1)
# Fonction pour créer un compte utilisateur avec 1000 crédits à l'inscription
def creer_compte(nom_utilisateur):
try:
cursor.execute("INSERT INTO comptes (nom_utilisateur, solde_banque, solde_jeux, dernier_credit) VALUES (?, 1000, 0, ?)", (nom_utilisateur, datetime.now().date()))
conn.commit()
return True
except mariadb.Error as e:
print(f"Erreur lors de la création du compte: {e}")
conn.rollback()
return False
def generer_page_stats_joueurs():
try:
# Récupérer tous les comptes
cursor.execute("SELECT nom_utilisateur, solde_banque, solde_jeux FROM comptes")
joueurs = cursor.fetchall()
# Commencer la construction de la page HTML avec styles CSS
html_content = """
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>Statistiques des Joueurs</title>
<style>
body {
font-family: Arial, sans-serif;
background-color: #f4f4f9;
color: #333;
margin: 0;
display: flex;
flex-direction: column;
min-height: 100vh;
}
h1 {
text-align: center;
background-color: #4CAF50;
color: white;
padding: 20px 0;
margin-bottom: 20px;
}
table {
width: 70%;
margin: 0 auto;
border-collapse: collapse;
box-shadow: 0 4px 8px rgba(0, 0, 0, 0.1);
background-color: #fff;
}
th, td {
padding: 12px;
text-align: center;
border-bottom: 1px solid #ddd;
}
th {
background-color: #4CAF50;
color: white;
}
tr:hover {
background-color: #f1f1f1;
}
td {
color: #555;
}
.footer {
text-align: center;
padding: 20px;
background-color: #4CAF50;
color: white;
margin-top: auto;
}
.commands {
margin: 20px auto;
width: 70%;
background-color: #e7f3fe;
padding: 15px;
border-radius: 5px;
box-shadow: 0 2px 4px rgba(0, 0, 0, 0.1);
}
</style>
</head>
<body>
<h1>Statistiques des Joueurs</h1>
<table>
<tr>
<th>Nom d'utilisateur</th>
<th>Solde Banque</th>
<th>Solde Jeux</th>
</tr>
"""
# Ajouter chaque joueur dans le tableau HTML
for joueur in joueurs:
nom_utilisateur, solde_banque, solde_jeux = joueur
html_content += f"""
<tr>
<td>{nom_utilisateur}</td>
<td>{solde_banque} crédits</td>
<td>{solde_jeux} crédits</td>
</tr>
"""
# Section des commandes
html_content += """
</table>
<div class="commands">
<h2>Commandes disponibles</h2>
<p><strong>!register [nom_utilisateur]</strong> : Créer un compte.</p>
<p><strong>!solde [nom_utilisateur]</strong> : Voir le solde du compte.</p>
<p><strong>!convertir [montant]</strong> : Convertir vos crédits de jeux en banque.</p>
<p><strong>!casino [montant]</strong> : Jouer au jeu du casino (ex: !casino 50).</p>
<p><strong>!roulette [nombre]</strong> : Jouer au jeu de la roulette.</p>
<p><strong>!slots [montant]</strong> : Jouer aux machines à sous.</p>
<p><strong>!des [montant]</strong> : Jouer au jeu de dés.</p>
<p><strong>!transfert [montant] : transfert des crédits de votre compte en banque vers votre compte de jeux.</p>
<p>Rejoignez le salon <strong>#casino</strong> pour jouer !</p>
</div>
<div class="footer">
<p>© 2024 Casino IRC Python By Maxime - Tous droits réservés.</p>
</div>
</body>
</html>
"""
# Chemin de la page HTML à générer
chemin_html = "/var/www/html/stats_joueurs.html"
# Écrire le contenu HTML dans un fichier
with open(chemin_html, "w") as file:
file.write(html_content)
print(f"Page HTML générée avec succès à l'emplacement: {chemin_html}")
except mariadb.Error as e:
print(f"Erreur lors de la génération de la page HTML: {e}")
# Exemple d'utilisation : Créer un compte puis générer la page HTML des stats
if creer_compte("Elias"):
print("Compte Elias créé avec succès.")
else:
print("Échec de la création du compte.")
# Générer la page HTML avec les statistiques des joueurs
generer_page_stats_joueurs()
# Ajouter une fonction pour vérifier si un utilisateur est enregistré
def est_enregistre(nom_utilisateur):
try:
cursor.execute("SELECT * FROM comptes WHERE nom_utilisateur=?", (nom_utilisateur,))
row = cursor.fetchone()
return row is not None
except mariadb.Error as e:
print(f"Erreur lors de la vérification de l'enregistrement de l'utilisateur: {e}")
return False
# Fonction pour récupérer le solde d'un utilisateur
def get_solde(nom_utilisateur):
try:
cursor.execute("SELECT solde_banque, solde_jeux FROM comptes WHERE nom_utilisateur=?", (nom_utilisateur,))
row = cursor.fetchone()
if row:
return row
else:
return None
except mariadb.Error as e:
print(f"Erreur lors de la récupération du solde: {e}")
return None
# Fonction pour récupérer le solde en banque d'un utilisateur
def get_solde_banque(nom_utilisateur):
try:
cursor.execute("SELECT solde_banque FROM comptes WHERE nom_utilisateur=?", (nom_utilisateur,))
row = cursor.fetchone()
if row:
return row[0]
else:
return None
except mariadb.Error as e:
print(f"Erreur lors de la récupération du solde en banque: {e}")
return None
def ajouter_argent(nom_administrateur, commande):
# Vérifie si l'utilisateur est un administrateur
if nom_administrateur not in administrateurs:
return f"{Fore.RED}Vous n'êtes pas autorisé à exécuter cette commande.{Fore.RESET}"
mots = commande.split()
if len(mots) != 3:
return f"{Fore.RED}Commande invalide. Utilisation : !ajouterargent [nom_utilisateur] [montant]{Fore.RESET}"
nom_utilisateur, montant_str = mots[1], mots[2]
try:
montant = int(montant_str)
except ValueError:
return f"{Fore.RED}Le montant doit être un nombre entier.{Fore.RESET}"
# Appel à la fonction pour créditer le compte
if crediter_compte(nom_utilisateur, montant):
return f"{Fore.GREEN}Montant de {montant} crédits ajouté avec succès au compte de {nom_utilisateur}.{Fore.RESET}"
else:
return f"{Fore.RED}Erreur lors de l'ajout de crédits au compte de {nom_utilisateur}.{Fore.RESET}"
def crediter_compte(nom_utilisateur, montant):
try:
cursor.execute("SELECT solde_banque FROM comptes WHERE nom_utilisateur=?", (nom_utilisateur,))
row = cursor.fetchone()
if row:
nouveau_solde_banque = row[0] + montant
cursor.execute("UPDATE comptes SET solde_banque=? WHERE nom_utilisateur=?", (nouveau_solde_banque, nom_utilisateur))
conn.commit()
return True
else:
return False
except mariadb.Error as e:
print(f"{Fore.RED}Erreur lors de la mise à jour du solde en banque: {e}{Fore.RESET}")
conn.rollback()
return False
def acheter_article(nom_utilisateur, article, channel, irc):
# Définir les prix spécifiques pour chaque article
prix_articles = {
"operateur": 20000,
"halflop": 10000,
"voice": 5000
}
# Obtenir le prix de l'article demandé
prix_article = prix_articles.get(article, None)
if prix_article is None:
return f"{Fore.RED}Article inconnu. Choisissez entre 'operateur', 'halflop', 'voice'.{Fore.RESET}"
solde_banque = get_solde_banque(nom_utilisateur)
if solde_banque is None:
return f"{Fore.RED}Utilisateur non trouvé. Veuillez d'abord vous enregistrer avec la commande !register.{Fore.RESET}"
if solde_banque >= prix_article:
nouveau_solde_banque = solde_banque - prix_article
if mettre_a_jour_solde_banque(nom_utilisateur, nouveau_solde_banque):
# Envoyer les commandes de mode selon l'article acheté
if article == "operateur":
irc.send(f"MODE {channel} +o {nom_utilisateur}\n".encode()) # Opérer l'utilisateur
elif article == "halflop":
irc.send(f"MODE {channel} +h {nom_utilisateur}\n".encode()) # Half-op l'utilisateur
elif article == "voice":
irc.send(f"MODE {channel} +v {nom_utilisateur}\n".encode()) # Voice l'utilisateur
return f"{Fore.GREEN}Achat réussi : {article}. Vous êtes maintenant {article} sur {channel}. Nouveau solde en banque : {nouveau_solde_banque}{Fore.RESET}"
else:
return f"{Fore.RED}Erreur lors de la mise à jour du solde.{Fore.RESET}"
else:
return f"{Fore.RED}Solde insuffisant pour acheter {article}. Solde en banque : {solde_banque}{Fore.RESET}"
def gestion_commande(nom_utilisateur, commande):
mots = commande.split()
if mots[0] == "!acheter" and len(mots) == 2:
article = mots[1]
if article in ["autovoice", "halflop", "operateur"]:
return acheter_article(nom_utilisateur, article)
else:
return f"{Fore.RED}Article inconnu. Veuillez choisir parmi 'autovoice', 'halflop', 'operateur'.{Fore.RESET}"
return "Commande invalide ou non reconnue."
def gestion_commande(nom_utilisateur, commande):
mots = commande.split()
if mots[0] == "!deposer":
if len(mots) == 2:
montant = int(mots[1])
if montant > 0:
solde_jeux = get_solde_jeux(nom_utilisateur)
if solde_jeux is not None and solde_jeux >= montant:
nouveau_solde_jeux = solde_jeux - montant
solde_banque = get_solde_banque(nom_utilisateur)
if solde_banque is not None:
nouveau_solde_banque = solde_banque + montant
if mettre_a_jour_solde(nom_utilisateur, nouveau_solde_banque, nouveau_solde_jeux):
return f"{Fore.BLUE}Vous avez déposé {montant} crédits de jeux dans votre compte en banque. Nouveau solde en banque : {nouveau_solde_banque}, Nouveau solde en jeux : {nouveau_solde_jeux}"
else:
return f"{Fore.RED}Une erreur est survenue lors du dépôt."
else:
return f"{Fore.RED}Utilisateur non trouvé veuiller dabors vous enregistre avec la commande !register."
else:
return f"{Fore.RED}Solde en jeux insuffisant."
else:
return f"{Fore.RED}Le montant doit être supérieur à zéro."
else:
return f"{Fore.RED}Commande invalide. Utilisation : !deposer [montant]"
elif mots[0] == "!transfert":
if len(mots) == 2:
montant = int(mots[1])
return transfert_credit(nom_utilisateur, montant)
else:
return f"{Fore.RED}Commande invalide. Utilisation : !transfert [montant]"
elif mots[0] == "!convertir":
if len(mots) == 2:
montant = int(mots[1])
if montant > 0:
solde_jeux = get_solde_jeux(nom_utilisateur)
if solde_jeux is not None and solde_jeux >= montant:
nouveau_solde_jeux = solde_jeux - montant
solde_banque = get_solde_banque(nom_utilisateur)
if solde_banque is not None:
nouveau_solde_banque = solde_banque + montant
if mettre_a_jour_solde(nom_utilisateur, nouveau_solde_banque, nouveau_solde_jeux):
return f"{Fore.BLUE}Vous avez converti {montant} crédits de jeux en {montant} crédits en banque. Nouveau solde en banque : {nouveau_solde_banque}, Nouveau solde en jeux : {nouveau_solde_jeux}"
else:
return f"{Fore.RED}Une erreur est survenue lors de la conversion."
else:
return f"{Fore.RED}Utilisateur non trouvé veuiller dabors vous enregistre avec la commande !register."
else:
return f"{Fore.RED}Solde en jeux insuffisant."
else:
return f"{Fore.RED}Le montant doit être supérieur à zéro."
else:
return f"{Fore.RED}Commande invalide. Utilisation : !convertir [montant]"
elif commande.startswith("!solde_banque"):
solde_banque = get_solde_banque(nom_utilisateur)
if solde_banque is not None:
return f"{Fore.BLUE}Solde en banque : {solde_banque}"
else:
return f"{Fore.RED}Utilisateur non trouvé veuiller dabors vous enregistre avec la commande !register."
elif commande.startswith("!solde_jeux"):
solde_jeux = get_solde_jeux(nom_utilisateur)
if solde_jeux is not None:
return f"{Fore.BLUE}Solde en jeux : {solde_jeux}"
else:
return f"{Fore.RED}Utilisateur non trouvé veuiller dabors vous enregistre avec la commande !register."
if commande.startswith("!solde_banque"):
solde_banque = get_solde_banque(nom_utilisateur)
if solde_banque is not None:
return f"Solde en banque : {solde_banque}"
else:
return "Utilisateur non trouvé veuiller dabors vous enregistre avec la commande !register."
mots = commande.split()
if mots[0] == "!deposer":
if len(mots) == 2:
montant = int(mots[1])
if montant > 0:
solde_banque = get_solde_banque(nom_utilisateur)
if solde_banque is not None:
nouveau_solde_banque = solde_banque + montant
if mettre_a_jour_solde_banque(nom_utilisateur, nouveau_solde_banque):
return f"Vous avez déposé {montant} crédits dans votre compte en banque. Nouveau solde en banque : {nouveau_solde_banque}"
else:
return "Une erreur est survenue lors du dépôt."
else:
return "Utilisateur non trouvé veuiller dabors vous enregistre avec la commande !register."
else:
return "Le montant doit être supérieur à zéro."
else:
return "Commande invalide. Utilisation : !deposer [montant]"
elif commande.startswith("!solde_banque"):
solde_banque = get_solde_banque(nom_utilisateur)
if solde_banque is not None:
return f"Solde en banque : {solde_banque}"
else:
return "Utilisateur non trouvé veuiller dabors vous enregistre avec la commande !register."
if not est_enregistre(nom_utilisateur): # Vérifier si le joueur est enregistré
return f"{Fore.RED}Vous devez d'abord vous enregistrer avec !register pour jouer.{Fore.END}"
def get_solde_jeux(nom_utilisateur):
try:
cursor.execute("SELECT solde_jeux FROM comptes WHERE nom_utilisateur=?", (nom_utilisateur,))
row = cursor.fetchone()
if row:
return row[0]
else:
return None
except mariadb.Error as e:
print(f"{Fore.RED}Erreur lors de la récupération du solde de jeux: {e}{Fore.END}")
return None
def mettre_a_jour_solde_banque(nom_utilisateur, nouveau_solde_banque):
try:
cursor.execute("UPDATE comptes SET solde_banque=? WHERE nom_utilisateur=?", (nouveau_solde_banque, nom_utilisateur))
conn.commit()
return True
except mariadb.Error as e:
print(f"{Fore.RED}Erreur lors de la mise à jour du solde en banque: {e}{Fore.END}")
conn.rollback()
return False
def mettre_a_jour_solde(nom_utilisateur, solde_banque, solde_jeux):
try:
cursor.execute("UPDATE comptes SET solde_banque=?, solde_jeux=? WHERE nom_utilisateur=?", (solde_banque, solde_jeux, nom_utilisateur))
conn.commit() # Assurez-vous que les modifications sont engagées
generer_page_stats_joueurs() # Générer la page des stats après la mise à jour
return True
except mariadb.Error as e:
print(f"Erreur lors de la mise à jour du solde: {e}")
return False
def transfert_credit(nom_utilisateur, montant):
solde_banque = get_solde_banque(nom_utilisateur)
solde_jeux = get_solde_jeux(nom_utilisateur)
if solde_banque is None:
return f"{Fore.RED}Utilisateur non trouvé. Veuillez d'abord vous enregistrer avec la commande !register."
if montant <= 0:
return f"{Fore.RED}Le montant doit être supérieur à zéro."
if solde_banque < montant:
return f"{Fore.RED}Solde insuffisant dans votre compte en banque."
nouveau_solde_banque = solde_banque - montant
nouveau_solde_jeux = solde_jeux + montant
if mettre_a_jour_solde(nom_utilisateur, nouveau_solde_banque, nouveau_solde_jeux):
return f"{Fore.BLUE}Vous avez transféré {montant} crédits de votre compte en banque vers votre compte de jeux. Nouveau solde en banque : {nouveau_solde_banque}, Nouveau solde en jeux : {nouveau_solde_jeux}"
else:
return f"{Fore.RED}Une erreur est survenue lors du transfert de crédits."
def gestion_commande_casino(nom_utilisateur, commande):
match = re.match(r"!casino (\d+)", commande)
if match:
montant = int(match.group(1))
solde = get_solde(nom_utilisateur)
solde_jeux = get_solde_jeux(nom_utilisateur) # Récupérer le solde de jeux de l'utilisateur
if solde_jeux:
if solde:
solde_banque, solde_jeux = solde
if solde_banque >= montant:
if gagner_ou_perdre():
solde_banque -= montant
solde_jeux += montant * 2
message = f"{Fore.BLUE}Vous avez gagné {montant} ! Votre nouveau solde en jeux est de {solde_jeux}.{Fore.RESET}"
else:
solde_banque -= montant
solde_jeux -= montant
message = f"{Fore.RED}Vous avez perdu {montant} ! Votre solde en banque est de {solde_banque}. Votre solde en jeux est de {solde_jeux}.{Color.END}"
if mettre_a_jour_solde(nom_utilisateur, solde_banque, solde_jeux):
return message
else:
return f"{Color.PURPLE}Solde insuffisant dans votre banque.{Color.END}"
else:
return f"{Color.PURPLE}Solde insuffisant dans votre banque.{Color.END}"
else:
return f"{Fore.RED}Vous n'avez pas suffisamment de crédits de jeux pour jouer veuillez faire un transfert [!transfert montant].{Color.END}"
else:
return f"{Fore.RED}Commande invalide. Utilisation : !casino [montant]{Fore.RESET}"
def gestion_commande_stats(nom_utilisateur, commande):
print(f"Commande reçue: {commande}") # Pour le débogage
if commande == "!statscas":
print(f"{nom_utilisateur} a demandé à voir les statistiques.")
return f"Voici les statistiques des joueurs: [Cliquez ici pour voir les stats](http://51.38.113.103/stats_joueurs.html)"
# Autres commandes à gérer
# ...
# Testez la fonction manuellement
response = gestion_commande_casino("joueur_test", "!statscas")
print(response) # Cela devrait afficher le message avec le lien
# Testez la fonction manuellement
response = gestion_commande_casino("joueur_test", "!statscas")
print(response) # Cela devrait afficher le message avec le lien
def jeu_de_des(nom_utilisateur, montant_mise):
if montant_mise <= 0:
return f"{Fore.RED}Le montant de la mise doit être supérieur à zéro.{Fore.RESET}"
solde_banque = get_solde_banque(nom_utilisateur)
if solde_banque is None:
return f"{Fore.RED}Utilisateur non trouvé. Veuillez d'abord vous enregistrer avec la commande !register.{Fore.RESET}"
if solde_banque < montant_mise:
return f"{Fore.RED}Solde insuffisant.{Fore.RESET}"
# Lancement du dé
resultat = random.randint(1, 6)
if resultat == 6:
gain = montant_mise * 2 # Gain: double de la mise si le résultat est 6
solde_banque += gain
message = f"{Fore.GREEN}Vous avez lancé un 6 et gagné {gain} crédits!{Fore.RESET}"
else:
solde_banque -= montant_mise
message = f"{Fore.RED}Vous avez lancé un {resultat}. Vous perdez votre mise de {montant_mise} crédits.{Fore.RESET}"
# Mise à jour du solde en banque après le jeu
if mettre_a_jour_solde_banque(nom_utilisateur, solde_banque):
message += f" Nouveau solde en banque : {solde_banque}"
else:
message = f"{Fore.RED}Une erreur est survenue lors de la mise à jour du solde.{Fore.RESET}"
return message
def gestion_commande_roulette(nom_utilisateur, commande):
mots = commande.split()
if mots[0] == "!roulette":
if len(mots) == 2:
montant = int(mots[1])
solde = get_solde(nom_utilisateur)
if solde:
solde_banque, solde_jeux = solde
if solde_banque >= montant:
resultat_jeu = jeu_roulette()
numero_gagnant, couleur, parite = resultat_jeu
if gagner_ou_perdre():
solde_jeux += montant * 2
message = f"La bille est tombée sur le {numero_gagnant} ({couleur}, {parite}). Vous avez gagné {montant} crédits !"
else:
solde_jeux -= montant
message = f"La bille est tombée sur le {numero_gagnant} ({couleur}, {parite}). Vous avez perdu {montant} crédits !"
if mettre_a_jour_solde(nom_utilisateur, solde_banque, solde_jeux):
message += " Veuillez attendre 30 secondes avant de jouer à nouveau."
irc.send(f"PRIVMSG {channel} :{message}\n".encode())
time.sleep(30)
else:
message = "Une erreur est survenue lors de la mise à jour du solde."
else:
message = "Solde insuffisant dans votre banque."
else:
message = "Utilisateur non trouvé veuillez d'abord vous enregistrer avec la commande !register."
else:
message = "Commande invalide. Utilisation : !roulette [montant]"
else:
message = "Commande invalide."
return message
# Définition de la variable globale symboles
symboles = {
"🍒": 10,
"🍊": 20,
"🍋": 30,
"🍉": 40,
"🍇": 50,
"🔔": 75,
"💎": 100,
"🎰": 200
}
# Initialisation de la variable globale jackpot
jackpot = 1
def jeu_slots(nom_utilisateur, montant_mise):
solde_banque = get_solde_banque(nom_utilisateur)
solde_jeux = get_solde_jeux(nom_utilisateur)
if solde_banque is None or solde_jeux is None:
return "Solde insuffisant dans votre banque pour effectuer cette mise."
if solde_banque >= montant_mise:
solde_banque -= montant_mise
symboles_tires = [random.choice(list(symboles.keys())) for _ in range(3)]
resultat = [symboles[symbole] for symbole in symboles_tires]
symboles_alignes = len(set(symboles_tires))
if jackpot == 1 and symboles_alignes == 1:
jackpot_amount = random.randint(1000, 10000)
solde_jeux += jackpot_amount
message = f"Jackpot !! Vous avez gagné {jackpot_amount} crédits de jeux ! Résultat: {' - '.join(symboles_tires)}."
elif symboles_alignes == 2:
gain = montant_mise * 2
solde_jeux += gain
message = f"Bravo ! Vous avez gagné {gain} crédits de jeux ! Résultat: {' - '.join(symboles_tires)}."
else:
message = f"Dommage ! Vous n'avez rien gagné cette fois-ci. Résultat: {' - '.join(symboles_tires)}."
# Mise à jour du solde et préparation du message final
if mettre_a_jour_solde(nom_utilisateur, solde_banque, solde_jeux):
message += " Veuillez attendre 30 secondes avant de jouer à nouveau."
else:
message = "Une erreur est survenue lors de la mise à jour du solde."
else:
message = "Solde insuffisant dans votre banque pour effectuer cette mise."
# Envoyer le message et appliquer le délai après toutes les interactions
irc.send(f"PRIVMSG {channel} :{message}\n".encode())
time.sleep(30) # Attendre 30 secondes avant que le joueur puisse rejouer
return message
articles = {
"Livre": 50,
"Montre": 100,
"Console de jeu": 200,
"Vélo": 300,
"Smartphone": 500
}
def jeu_juste_prix(nom_utilisateur, montant_mise):
solde_banque = get_solde_banque(nom_utilisateur)
if solde_banque is not None and solde_banque >= montant_mise:
solde_banque -= montant_mise
prix_a_deviner = random.randint(1, 100)
numero_propose = random.randint(1, 100)
if numero_propose == prix_a_deviner:
gain = montant_mise * 2
solde_jeux = get_solde_jeux(nom_utilisateur)
solde_jeux += gain
message = f"Bravo ! Vous avez deviné le juste prix ({prix_a_deviner}) ! Vous avez gagné {gain} crédits de jeux."
else:
message = f"Dommage ! Le juste prix était {prix_a_deviner}. Vous avez perdu votre mise."
if mettre_a_jour_solde(nom_utilisateur, solde_banque, solde_jeux):
message += " Veuillez attendre 30 secondes avant de jouer à nouveau."
irc.send(f"PRIVMSG {channel} :{message}\n".encode())
time.sleep(30)
else:
message = "Une erreur est survenue lors de la mise à jour du solde."
else:
message = "Solde insuffisant dans votre banque pour effectuer cette mise."
return message
def attribuer_article(montant_mise):
for article, valeur in articles.items():
if montant_mise * 2 >= valeur:
return article
return "Aucun article"
def gagner_ou_perdre():
return random.choice([True, False])
def jeu_roulette():
numero_gagnant = random.randint(0, 36)
if numero_gagnant % 2 == 0:
parite = "pair"
else:
parite = "impair"
if numero_gagnant == 0:
couleur = "vert"
elif (numero_gagnant >= 1 and numero_gagnant <= 10) or (numero_gagnant >= 19 and numero_gagnant <= 28):
if numero_gagnant % 2 == 0:
couleur = "noir"
else:
couleur = "rouge"
else:
if numero_gagnant % 2 == 0:
couleur = "rouge"
else:
couleur = "noir"
return numero_gagnant, couleur, parite
# Définir une liste d'administrateurs autorisés
administrateurs = ["Maxime", "KoS_"] # Remplacez ceci par les noms des administrateurs réels
# Ajouter une fonction pour envoyer de l'aide
def envoyer_aide(nom_utilisateur):
if nom_utilisateur in administrateurs:
irc.send(f"PRIVMSG {nom_utilisateur} :\x0304Commandes disponibles (administrateur) :\n".encode())
irc.send(f"PRIVMSG {nom_utilisateur} : \x0310- !register [nom_utilisateur] : Créer un compte.\n".encode())
irc.send(f"PRIVMSG {nom_utilisateur} : \x0310- !solde [nom_utilisateur] : Voir le solde du compte.\n".encode())
irc.send(f"PRIVMSG {nom_utilisateur} : \x0310- !convertir [montant] converti vos credit de jeux et les met en banque.\n".encode())
irc.send(f"PRIVMSG {nom_utilisateur} : \x0310- !transfert [montant] : transfert des crédits de votre compte en banque vers votre compte de jeux.\n".encode())
irc.send(f"PRIVMSG {nom_utilisateur} : \x0310- !roulette [nombre] : jouer au jeux de la roulette.\n".encode())
irc.send(f"PRIVMSG {nom_utilisateur} : \x0310- !casino [montant] : joue au jeu du casino (ex: !casino 50).\n".encode())
irc.send(f"PRIVMSG {nom_utilisateur} : \x0310- !slots [montant] : joue au machine a sous.\n".encode())
irc.send(f"PRIVMSG {nom_utilisateur} : \x0310- !des [montant] : joue au jeux de dès.\n".encode())
irc.send(f"PRIVMSG {nom_utilisateur} : \x0310- !quit : Déconnecter le bot.\n".encode())
irc.send(f"PRIVMSG {nom_utilisateur} : \x0310- !join [#channel] : fait joindre le bot sur un channel.\n".encode())
irc.send(f"PRIVMSG {nom_utilisateur} : \x0310- !part [#channel] : fait Partire le bot d'un channel.\n".encode())
irc.send(f"PRIVMSG {nom_utilisateur} : \x0310- !supprime [nom_utilisateur] : Supprimer un compte.\n".encode())
irc.send(f"PRIVMSG {nom_utilisateur} : \x0310- !ajouterargent [nom_utilisateur] [montant] : credite de l'agennt sur le compte d'un joueur.\n".encode())
else:
irc.send(f"PRIVMSG {nom_utilisateur} :\x0304Commandes disponibles :\n".encode())
irc.send(f"PRIVMSG {nom_utilisateur} : \x0310- !register [nom_utilisateur] : Créer un compte.(ex: register Maxime)\n".encode())
irc.send(f"PRIVMSG {nom_utilisateur} : \x0310- !casino [montant] : joue au jeu du casino (ex: !casino 50).\n".encode())
irc.send(f"PRIVMSG {nom_utilisateur} : \x0310- !solde [nom_utilisateur] : Voir le solde du compte.\n".encode())
irc.send(f"PRIVMSG {nom_utilisateur} : \x0310- !convertir [montant] converti vos credit de jeux et les met en banque.\n".encode())
irc.send(f"PRIVMSG {nom_utilisateur} : \x0310- !transfert [montant] : transfert des crédits de votre compte en banque vers votre compte de jeux.\n".encode())
irc.send(f"PRIVMSG {nom_utilisateur} : \x0310- !roulette [nombre] : jouer au jeux de la roulette.\n".encode())
irc.send(f"PRIVMSG {nom_utilisateur} : \x0310- !slots [montant] : joue au machine a sous.\n".encode())
irc.send(f"PRIVMSG {nom_utilisateur} : \x0310- !des [montant] : joue au jeux de dès.\n".encode())
# Ajouter une commande pour supprimer un compte
def supprimer_compte(administrateur):
try:
cursor.execute("DELETE FROM comptes WHERE nom_utilisateur=?", (administrateur,))
conn.commit()
return True
except mariadb.Error as e:
print(f"Erreur lors de la suppression du compte: {e}")
conn.rollback()
return False
# Configuration IRC changer les infos
server = "irc.extra-cool.fr"
port = 6697 # Port TLS/SSL pour IRC
channel = "#extra-cool"
logs_channel = "#logs"
casino_channel = "#casino"
bot_name = "CasinoBot"
bot_channels = set()
irc_channels = ["#extra-cool", "#casino", "#casinoadmin"]
nickname = "CasinoBot"
password = "votre-mot-de-pass"
nickserv_password = "votre-mot-de-pass"
ircop_password = "votre-mot-de-pass" # Ajoutez votre mot de passe IRCop ici
admins_file = "admins.txt"
# Lire les administrateurs depuis un fichier
def lire_admins():
if not os.path.exists(admins_file):
return set()
with open(admins_file, "r") as f:
return set(line.strip() for line in f)
# Lire les administrateurs depuis un fichier
def lire_admins():
if not os.path.exists(admins_file):
return set()
with open(admins_file, "r") as f:
return set(line.strip() for line in f)
admin_users = lire_admins()
print("Admins initiaux : ", admin_users) # Debugging output
# Enregistrer les administrateurs dans un fichier
def enregistrer_admins():
with open(admins_file, "w") as f:
for admin in admin_users:
f.write(f"{admin}\n")
print("Admins enregistrés : ", admin_users) # Debugging output
# Variable pour activer ou désactiver le mode débogage
debug_mode = True
# Fonction pour logger les commandes
def log_commande(message):
irc.send(f"PRIVMSG {logs_channel} :{message}\n".encode())
# Fonction pour se connecter et s'identifier
def identify_and_oper():
# Identifier auprès de NickServ
irc.send(f"PRIVMSG NickServ :IDENTIFY {nickserv_password}\n".encode())
log_commande("[info]==> Identification auprès de NickServ envoyée.")
time.sleep(5) # Attendre un peu pour s'assurer que l'identification est traitée
# Obtenir les privilèges d'opérateur (IRCop)
irc.send(f"OPER {nickname} {ircop_password}\n".encode())
log_commande("[info]==> Commande OPER envoyée pour obtenir les privilèges IRCop.")
time.sleep(5) # Attendre un peu pour s'assurer que la commande est traitée
# Obtenir les privilèges d'opérateur de canal
irc.send(f"PRIVMSG ChanServ :OP {nickname}\n".encode())
log_commande("[info]==> Commande OP envoyée à ChanServ.")
# Fonction pour traiter la demande et envoyer un message à #casinoadmin
def traiter_demande(sender, channel_demande):
log_message = f"[info]==> {sender} a fait une demande aux admins pour rejoindre le salon {channel_demande}"
print(log_message) # Afficher pour le débogage
irc.send(f"PRIVMSG #casinoadmin :{log_message}\n".encode())
response = irc.recv(2048).decode("UTF-8")
print(response) # Afficher la réponse du serveur pour le débogage
log_commande(log_message)
# Faire rejoindre le salon demandé
irc.send(f"JOIN {channel_demande}\n".encode())
bot_channels.add(channel_demande)
log_commande(f"[info]==> Bot a rejoint le salon {channel_demande}")
# Fonction pour redémarrer le bot
def restart_bot():
log_commande("[info]==> Redémarrage du bot...")
python = sys.executable
os.execl(python, python, *sys.argv)
# Fonction pour ajouter un administrateur
def ajouter_admin(nouveau_admin, sender):
if sender not in admin_users:
irc.send(f"PRIVMSG {sender} :Vous n'avez pas les droits pour ajouter un administrateur.\n".encode())
log_commande(f"Ajout d'administrateur refusé pour {sender}")
return
if nouveau_admin in admin_users:
irc.send(f"PRIVMSG {sender} :{nouveau_admin} est déjà un administrateur.\n".encode())
log_commande(f"Ajout d'administrateur échoué: {nouveau_admin} est déjà administrateur")
return
admin_users.add(nouveau_admin)
enregistrer_admins() # Enregistrer les administrateurs après ajout
irc.send(f"PRIVMSG {sender} :{nouveau_admin} a été ajouté comme administrateur.\n".encode())
log_commande(f"{nouveau_admin} ajouté comme administrateur par {sender}")
# Fonction pour supprimer un administrateur
def supprimer_admin(admin_a_supprimer, sender):
if sender not in admin_users:
irc.send(f"PRIVMSG {sender} :Vous n'avez pas les droits pour supprimer un administrateur.\n".encode())
log_commande(f"Suppression d'administrateur refusée pour {sender}")
return
if admin_a_supprimer not in admin_users:
irc.send(f"PRIVMSG {sender} :{admin_a_supprimer} n'est pas un administrateur.\n".encode())
log_commande(f"Suppression d'administrateur échouée: {admin_a_supprimer} n'est pas administrateur")
return
admin_users.remove(admin_a_supprimer)
enregistrer_admins() # Enregistrer les administrateurs après suppression
irc.send(f"PRIVMSG {sender} :{admin_a_supprimer} a été supprimé des administrateurs.\n".encode())
log_commande(f"{admin_a_supprimer} supprimé des administrateurs par {sender}")
# Fonction pour envoyer la liste des administrateurs
def lister_admins(sender, channel):
admins_list = ", ".join(admin_users)
irc.send(f"PRIVMSG {channel} :Administrateurs actuels : {admins_list}\n".encode())
log_commande(f"Liste des administrateurs demandée par {sender}: {admins_list}")
# Création de la socket pour la connexion IRC
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((server, port))
# Création d'un contexte SSL
context = ssl.create_default_context()
# Envelopper la socket dans une couche SSL/TLS
irc = context.wrap_socket(sock, server_hostname=server)
# Envoyer les commandes IRC
irc.send(f"USER {bot_name} 0 * :{bot_name}\n".encode())
irc.send(f"NICK {bot_name}\n".encode())
registered = False
while not registered:
message = irc.recv(2048).decode("UTF-8")
print(message) # Afficher le message pour le débogage
# Répondre aux PINGs du serveur pour garder la connexion active
if "PING" in message:
cookie = message.split()[1]
irc.send(f"PONG {cookie}\n".encode())
# Vérifier si le bot est enregistré
if "001" in message:
registered = True
# S'identifier auprès de NickServ et obtenir les privilèges d'opérateur
identify_and_oper()
# Rejoindre les salons définis
irc.send(f"JOIN {channel}\n".encode())
irc.send(f"JOIN {logs_channel}\n".encode())
irc.send(f"JOIN {casino_channel}\n".encode())
for channel in irc_channels:
irc.send(f"JOIN {channel}\n".encode())
bot_channels.add(channel)
# Fonction pour envoyer l'annonce toutes les 5 minutes
def send_casino_announcement():
while True:
try:
# Message avec couleur rouge
message = "\x03" + "04" + "Rejoignez-nous sur #casino pour jouer au casino!" # Couleur 04 (rouge)
irc.send(f"PRIVMSG #extra-cool :{message}\n".encode()) # modifier votre salon
print("Message envoyé avec succès à #extra-cool")
time.sleep(300) # Attendre 300 secondes (5 minutes) avant d'envoyer le prochain message
except Exception as e:
print(f"Erreur lors de l'envoi du message : {e}")
# Lancer l'annonce dans un thread séparé
announcement_thread = threading.Thread(target=send_casino_announcement)
announcement_thread.daemon = True # Le thread se ferme lorsque le programme principal se ferme
announcement_thread.start()
# Boucle principale pour traiter les messages
while True:
message = irc.recv(2048).decode("UTF-8")
print(message) # Afficher le message pour le débogage
# Répondre aux PINGs du serveur pour garder la connexion active
if "PING" in message:
cookie = message.split()[1]
irc.send(f"PONG {cookie}\n".encode())
log_commande(f"PING/PONG maintenu avec {cookie}")
# Gérer le message d'erreur spécifique pour le salon #logs
if "404" in message and logs_channel in message:
print(f"[info]==>Erreur : Le bot ne peut pas poster dans {logs_channel} en raison de restrictions.")
irc.send(f"JOIN {logs_channel}\n".encode()) # Essayer de rejoindre à nouveau si non présent
irc.send(f"JOIN {casino_channel}\n".encode())
irc.send("JOIN #casinoadmin\n".encode())
continue
# Détection des messages de type JOIN
if "JOIN" in message:
join_match = re.match(r"^:(.*?)!.*JOIN\s+:(#\S+)", message)
if join_match:
user = join_match.group(1)
channel = join_match.group(2)
log_message = f"[info]==>{user} a rejoint le salon {channel}"
print(log_message) # Afficher pour le débogage
irc.send(f"PRIVMSG {logs_channel} :{log_message}\n".encode())
log_commande(log_message)
# Détection des messages de type PART
if "PART" in message:
part_match = re.match(r"^:(.*?)!.*PART\s+(#\S+)", message)
if part_match:
user = part_match.group(1)
channel = part_match.group(2)
log_message = f"[info]==>{user} a quitté le salon {channel}"
print(log_message) # Afficher pour le débogage
irc.send(f"PRIVMSG {logs_channel} :{log_message}\n".encode())
log_commande(log_message)
elif "PRIVMSG" in message:
sender_match = re.match(r"^:(.*?)!", message)
channel_match = re.search(r"PRIVMSG (#\S+)", message)
msg_match = re.search(r"PRIVMSG #\S+ :(.*)", message)