historien.py

   1 #!/usr/bin/python
   2 # -*- coding:utf8 -*-
   3
   4 # Codé par 20-100 le 25/05/12
   5
   6 # Un bot IRC qui pose des questions d'histoire
   7
   8 import irclib
   9 import ircbot
  10 import threading
  11 import random
  12 import time
  13 import pickle
  14 import re
  15 from cast_as_date import *
  16
  17 config_password="EtTaMère,ElleEstNéeQuand?"
  18 config_pseudo="historien"
  19 config_chanlist=["#bot","#flood"]
  20 config_play_channels=["#flood"]
  21 config_stay_channels=["#flood","#bot"]
  22 config_overops=["[20-100]","[20-100]_"]
  23 config_ops=["PEB","Petite-Peste"]
  24
  25 config_source_file="dates.txt"
  26 config_played_file_template="played.%s.txt" #il faut rajouter le nom du serveur
  27 def get_config_played_file(serveur):
  28     serveurs={"acoeur.crans.org":"acoeur","irc.crans.org":"crans"}
  29     return config_played_file_template%(serveurs[serveur])
  30 ttrig=120 #time trigger (normalement 120, mais diminué pour les tests)
  31 Ttrig=600 #between two enigms
  32 config_time_incompressible=15 #on peut pas retrigger en dessous de ce temps (60)
  33 config_time_incompressible_clue=60 #on peut pas forcer la demande d'indice en dessous
  34
  35 config_score_file="scores.pickle"
  36
  37 config_tag_triggers=[u"t(|a)g",u"ta gueule",u"la ferme",u"ferme( |-)la",u"tais-toi",u"chut"]
  38 config_tag_actions=[u"se tait",u"ferme sa gueule",u"se la ferme",u"la ferme"]
  39 config_tag_answers=[u"J'me tais si j'veux !",
  40 u"Je t'entends pas :°",
  41 u"Héhé, try again",
  42 u"Non, j'ai pas envie",
  43 u"Peut-être quand toi tu la fermeras, et encore…"]
  44
  45 config_level2=[]
  46 config_level3=[]
  47
  48 config_debug_stdout = True
  49 config_logfile_template="historien.%s.log"
  50 def get_config_logfile(serveur):
  51     serveurs={"acoeur.crans.org":"acoeur","irc.crans.org":"crans"}
  52     return config_logfile_template%(serveurs[serveur])
  53
  54 config_quit_messages=[u"%s : %s quitte le serveur IRC"]
  55
  56 config_leave_messages=[u"%s : %s quitte le channel"]
  57
  58 class UnicodeBotError(Exception):
  59     pass
  60 def bot_unicode(chain):
  61     try:
  62         unicode(chain,"utf8")
  63     except UnicodeDecodeError:
  64         raise UnicodeBotError
  65
  66 def log(serveur,channel,auteur=None,message=None):
  67     f=open(get_config_logfile(serveur),"a")
  68     if auteur==message==None:
  69         # alors c'est que c'est pas un channel mais juste une ligne de log
  70         chain="%s %s"%(time.strftime("%F %T"),channel)
  71     else:
  72         chain="%s [%s:%s] %s"%(time.strftime("%F %T"),channel,auteur,message)
  73     f.write(chain+"\n")
  74     if config_debug_stdout:
  75         print chain
  76     f.close()
  77
  78
  79 def reussi(message,answer,auteur):
  80     print message, "#?#", answer
  81     if auteur in config_level3:
  82         return answer in message
  83     if auteur in config_level2:
  84         return answer in message
  85     else:
  86         try:
  87             date=cast_as_date(message.lower())
  88             print tuple(date)
  89         except ThisIsNotADate:
  90             return False
  91         as_string="%02d/%02d/%d"%(date[2],date[1],date[0])
  92         print as_string
  93         if as_string==answer:
  94             return True
  95         else:
  96             return False
  97
  98 def is_something(chain,matches,avant=u".*(?:^| )",apres=u"(?:$|\.| |,|;).*",case_sensitive=False,debug=False):
  99     if case_sensitive:
 100         chain=unicode(chain,"utf8")
 101     else:
 102         chain=unicode(chain,"utf8").lower()
 103     allmatches="("+"|".join(matches)+")"
 104     reg=(avant+allmatches+apres).lower()
 105     o=re.match(reg,chain)
 106     return o
 107
 108 def is_tag(chain):
 109     return is_something(chain,config_tag_triggers)
 110
 111 class RefuseError(Exception):
 112     pass
 113
 114 class Deconnaisseur(ircbot.SingleServerIRCBot):
 115     def __init__(self,serveur,debug=False):
 116         temporary_pseudo=config_pseudo+str(random.randrange(10000,100000))
 117         ircbot.SingleServerIRCBot.__init__(self, [(serveur, 6667)],
 118                                       temporary_pseudo,"Un bot irc qui a au moins l'agreg d'histoire", 10)
 119         self.debug=debug
 120         self.serveur=serveur
 121         self.overops=config_overops
 122         self.ops=self.overops+config_ops
 123         self.chanlist=config_chanlist
 124         self.stay_channels=config_stay_channels
 125         self.play_channels=config_play_channels
 126         self.play_status={i:[0] for i in self.play_channels}
 127         self.quiet_channels=[]
 128
 129     def give_me_my_pseudo(self,serv):
 130         serv.privmsg("NickServ","RECOVER %s %s"%(config_pseudo,config_password))
 131         serv.privmsg("NickServ","RELEASE %s %s"%(config_pseudo,config_password))
 132         time.sleep(0.3)
 133         serv.nick(config_pseudo)
 134
 135     def on_welcome(self, serv, ev):
 136         self.serv=serv # ça serv ira :)
 137         self.give_me_my_pseudo(serv)
 138         serv.privmsg("NickServ","identify %s"%(config_password))
 139         log(self.serveur,"Connected")
 140         if self.debug:
 141             self.chanlist=["#bot"]
 142             self.play_channels=["#bot"]
 143         for c in self.chanlist:
 144             log(self.serveur,"JOIN %s"%(c))
 145             serv.join(c)
 146         for c in self.play_channels:
 147             token=time.time()-3600
 148             self.play_status[c]=[0,token]
 149             serv.execute_delayed(random.randrange(ttrig),self.start_enigme,(serv,c,token))
 150
 151     def start_enigme(self,serv,channel,token=None):
 152         if self.play_status[channel][0]==0 and channel in self.play_channels:
 153             ok="skip"
 154             if token==self.play_status[channel][-1]:
 155                 ok="do_it"
 156             if token==None:
 157                 if time.time() > self.play_status[channel][-1]+config_time_incompressible:
 158                     ok="do_it"
 159                 else:
 160                     ok="refuse"
 161             if ok=="do_it":
 162                 date,evenement=self.get_enigme()
 163                 log(self.serveur,channel,u"$Date$".encode("utf8"),("%s : %s"%(date, evenement)).encode("utf8"))
 164                 serv.privmsg(channel,evenement.encode("utf8"))
 165                 token=time.time()
 166                 self.play_status[channel]=[1,date,evenement,token]
 167                 serv.execute_delayed(random.randrange(ttrig*3,ttrig*5),self.give_indice,(serv,channel,token))
 168             elif ok=="refuse":
 169                 raise RefuseError
 170     def give_indice(self,serv,channel,token):
 171         if self.play_status[channel][0]==1:
 172             if token==None:
 173                 # c'est donc que l'indice a été demandé
 174                 if self.play_status[channel][-1]+config_time_incompressible_clue<time.time():
 175                     token=self.play_status[channel][-1]
 176             if self.play_status[channel][-1]==token:
 177                 date=self.play_status[channel][1]
 178                 indice=date[:5]
 179                 serv.privmsg(channel,"indice : %s"%(indice).encode("utf8"))
 180                 self.play_status[channel][0]=2
 181                 serv.execute_delayed(random.randrange(ttrig*1,ttrig*3),self.give_answer,(serv,channel,token))
 182     def give_answer(self,serv,channel,token):
 183         if self.play_status[channel][0]==2 and self.play_status[channel][-1]==token:
 184             date=self.play_status[channel][1]
 185             serv.privmsg(channel,"C'était le %s"%(date).encode("utf8"))
 186             token=time.time()
 187             self.play_status[channel]=[0,token]
 188             serv.execute_delayed(random.randrange(Ttrig*5,Ttrig*10),self.start_enigme,(serv,channel,token))
 189
 190     def get_enigme(self):
 191         # on récupère les dates
 192         f=open(config_source_file)
 193         l=f.readlines()
 194         f.close()
 195         l=[i.split(" : ",2) for i in l]
 196         dates={int(i[0]):i[1:] for i in l}
 197         # on va chercher combien de fois elles ont été jouées
 198         played_file=get_config_played_file(self.serveur)
 199         f=open(played_file)
 200         t=f.read()
 201         f.close()
 202         l=re.findall("(.*):(.*)",t)
 203         played={int(i[0]):int(i[1]) for i in l}
 204         # on récupère le nombre d'occurrences le plus faible
 205         mini=min(played.values())
 206         # on choisit un id dans ceux qui ont ce nombre d'occurences
 207         id_choisi=random.choice([k for k,v in played.items() if v==mini])
 208         date,evenement=dates[id_choisi]
 209         evenement=evenement.replace("\n","")
 210         # on incrémente la choisie
 211         played[id_choisi]+=1
 212         # on enregistre le played_file
 213         f=open(played_file,"w")
 214         f.write("\n".join(["%-4s : %s"%(k,v) for k,v in played.items()]))
 215         f.close()
 216         return map(lambda x:x.decode("utf8"), [date,evenement])
 217
 218     def pourmoi(self, serv, message):
 219         pseudo=self.nick
 220         size=len(pseudo)
 221         if message[:size]==pseudo and len(message)>size and message[size]==":":
 222             return (True,message[size+1:].strip(" "))
 223         else:
 224             return (False,message)
 225
 226     def on_privmsg(self, serv, ev):
 227         message=ev.arguments()[0]
 228         auteur = irclib.nm_to_n(ev.source())
 229         try:
 230             test=bot_unicode(message)
 231         except UnicodeBotError:
 232             serv.privmsg(auteur,
 233               "Euh, tu fais de la merde avec ton encodage là, j'ai failli crasher…")
 234             return
 235         message=message.split()
 236         cmd=message[0].lower()
 237         notunderstood=False
 238         if cmd=="help":
 239             helpmsg_default="""Liste des commandes :
 240  HELP       Affiche ce message d'aide
 241  SCORE      Affiche ton score (SCORE TRANSFERT <pseudo> [<n>] pour transférer des points)
 242  SCORES     Affiche les scores"""
 243             helpmsg_ops="""
 244  JOIN       Faire rejoindre un channel (sans paramètres, donne la liste des chans actuels)
 245  LEAVE      Faire quitter un channel
 246  PLAY       Passe un channel en mode "jouer"
 247  NOPLAY     Passe un channel en mode "ne pas jouer"
 248  QUIET      Se taire sur un channel
 249  NOQUIET    Opposé de QUIET"""
 250             helpmsg_overops="""
 251  SCORES {DEL|ADD|SUB}   Tu veux un dessin ?
 252  SAY        Fais envoyer un message sur un chan ou à une personne
 253  STAY       Ignorera les prochains LEAVE pour un chan
 254  NOSTAY     Opposé de STAY
 255  STATUS     Montre l'état courant
 256  DIE        Mourir"""
 257             helpmsg=helpmsg_default
 258             if auteur in self.ops:
 259                 helpmsg+=helpmsg_ops
 260             if auteur in self.overops:
 261                 helpmsg+=helpmsg_overops
 262             for ligne in helpmsg.split("\n"):
 263                 serv.privmsg(auteur,ligne)
 264         elif cmd=="join":
 265             if auteur in self.ops:
 266                 if len(message)>1:
 267                     if message[1] in self.chanlist:
 268                         serv.privmsg(auteur,"Je suis déjà sur %s"%(message[1]))
 269                     else:
 270                         serv.join(message[1])
 271                         self.chanlist.append(message[1])
 272                         serv.privmsg(auteur,"Channels : "+" ".join(self.chanlist))
 273                         log(self.serveur,"priv",auteur," ".join(message))
 274                 else:
 275                     serv.privmsg(auteur,"Channels : "+" ".join(self.chanlist))
 276             else:
 277                 notunderstood=True
 278         elif cmd=="leave":
 279             if auteur in self.ops and len(message)>1:
 280                 if message[1] in self.chanlist:
 281                     if not (message[1] in self.stay_channels) or auteur in self.overops:
 282                         self.quitter(message[1]," ".join(message[2:]))
 283                         self.chanlist.remove(message[1])
 284                         log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 285                     else:
 286                         serv.privmsg(auteur,"Non, je reste !")
 287                         log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 288                 else:
 289                     serv.privmsg(auteur,"Je ne suis pas sur %s"%(message[1]))
 290             else:
 291                 notunderstood=True
 292         elif cmd=="stay":
 293             if auteur in self.overops:
 294                 if len(message)>1:
 295                     if message[1] in self.stay_channels:
 296                         serv.privmsg(auteur,"Je stay déjà sur %s."%(message[1]))
 297                         log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 298                     else:
 299                         self.stay_channels.append(message[1])
 300                         serv.privmsg(auteur,"Stay channels : "+" ".join(self.stay_channels))
 301                         log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 302                 else:
 303                     serv.privmsg(auteur,"Stay channels : "+" ".join(self.stay_channels))
 304             else:
 305                 notunderstood=True
 306         elif cmd=="nostay":
 307             if auteur in self.overops:
 308                 if len(message)>1:
 309                     if message[1] in self.stay_channels:
 310                         self.stay_channels.remove(message[1])
 311                         serv.privmsg(auteur,"Stay channels : "+" ".join(self.stay_channels))
 312                         log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 313                     else:
 314                         serv.privmsg(auteur,"Je ne stay pas sur %s."%(message[1]))
 315                         log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 316             else:
 317                 notunderstood=True
 318         elif cmd=="play":
 319             if auteur in self.ops:
 320                 if len(message)>1:
 321                     if message[1] in self.play_channels:
 322                         serv.privmsg(auteur,"Je play déjà sur %s."%(message[1]))
 323                         log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 324                     else:
 325                         self.play_channels.append(message[1])
 326                         self.play_status[message[1]]=[0,time.time()-3600]
 327                         serv.privmsg(auteur,"Play channels : "+" ".join(self.play_channels))
 328                         log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 329                 else:
 330                     serv.privmsg(auteur,"Play channels : "+" ".join(self.play_channels))
 331             else:
 332                 notunderstood=True
 333         elif cmd=="noplay":
 334             if auteur in self.ops:
 335                 if len(message)>1:
 336                     if message[1] in self.play_channels:
 337                         self.play_channels.remove(message[1])
 338                         serv.privmsg(auteur,"Play channels : "+" ".join(self.play_channels))
 339                         log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 340                     else:
 341                         serv.privmsg(auteur,"Je ne play pas sur %s."%(message[1]))
 342                         log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 343             else:
 344                 notunderstood=True
 345         elif cmd=="quiet":
 346             if auteur in self.ops:
 347                 if len(message)>1:
 348                     if message[1] in self.quiet_channels:
 349                         serv.privmsg(auteur,"Je me la ferme déjà sur %s"%(message[1]))
 350                         log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 351                     else:
 352                         self.quiet_channels.append(message[1])
 353                         serv.privmsg(auteur,"Quiet channels : "+" ".join(self.quiet_channels))
 354                         log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 355                 else:
 356                     serv.privmsg(auteur,"Quiet channels : "+" ".join(self.quiet_channels))
 357             else:
 358                 notunderstood=True
 359         elif cmd=="noquiet":
 360             if auteur in self.ops:
 361                 if len(message)>1:
 362                     if message[1] in self.quiet_channels:
 363                         self.quiet_channels.remove(message[1])
 364                         serv.privmsg(auteur,"Quiet channels : "+" ".join(self.quiet_channels))
 365                         log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 366                     else:
 367                         serv.privmsg(auteur,"Je ne me la ferme pas sur %s."%(message[1]))
 368                         log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 369             else:
 370                 notunderstood=True
 371         elif cmd in ["states","status"]:
 372             if auteur in self.overops:
 373                 for k in self.play_status.keys():
 374                     serv.privmsg(auteur,(u"%s : %s"%(k," | ".join([unicode(i) for i in self.play_status[k]]))).encode("utf8") )
 375         elif cmd=="say":
 376             if auteur in self.overops and len(message)>2:
 377                 serv.privmsg(message[1]," ".join(message[2:]))
 378                 log(self.serveur,"priv",auteur," ".join(message))
 379             elif len(message)<=2:
 380                 serv.privmsg(auteur,"Syntaxe : SAY <channel> <message>")
 381             else:
 382                 notunderstood=True
 383         elif cmd=="die":
 384             if auteur in self.overops:
 385                 log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 386                 self.mourir()
 387         elif cmd=="score":
 388             if len(message)>1:
 389                 if len(message) in [3,4] and message[1].lower()=="transfert":
 390                     scores=self.get_scores()
 391                     de,to=auteur,message[2]
 392                     value=scores.get(de,0)
 393                     if len(message)==4:
 394                         try:
 395                             asked=int(message[3])
 396                         except ValueError:
 397                             serv.privmsg(auteur,"Syntaxe : SCORE TRANSFERT <pseudo> [<n>]")
 398                             return
 399                     else:
 400                         asked=value
 401                     if value==0:
 402                         serv.privmsg(auteur,"Vous n'avez pas de points")
 403                         return
 404                     elif asked<=0:
 405                         serv.privmsg(auteur,"Bien tenté…")
 406                         return
 407                     elif asked>value:
 408                         serv.privmsg(auteur,"Vous n'avez que %s points"%(value))
 409                         return
 410                     else:
 411                         self.add_score(de,-asked)
 412                         self.add_score(to,asked)
 413                         serv.privmsg(auteur,"Transfert de %s points de %s à %s"%(asked,de,to))
 414                 else:
 415                     serv.privmsg(auteur,"Syntaxe : SCORE TRANSFERT <pseudo> [<n>]")
 416             else:
 417                 serv.privmsg(auteur,"Votre score : %s"%(self.get_scores().get(auteur,0)) )
 418         elif cmd=="scores":
 419             if len(message)==1:
 420                 scores=self.get_scores().items()
 421                 # trie par score
 422                 scores.sort(lambda x,y:cmp(x[1],y[1]))
 423                 scores.reverse()
 424                 serv.privmsg(auteur,"Scores by score : "+" ; ".join(["%s %s"%(i[0],i[1]) for i in scores]))
 425                 # trie par pseudo
 426                 scores.sort(lambda x,y:cmp(x[0].lower(),y[0].lower()))
 427                 serv.privmsg(auteur,"Scores by pseudo : "+" ; ".join(["%s %s"%(i[0],i[1]) for i in scores]))
 428             elif auteur in self.overops:
 429                 souscmd=message[1].lower()
 430                 if souscmd=="del":
 431                     if len(message)==3:
 432                         todelete=message[2]
 433                         scores=self.get_scores()
 434                         if scores.has_key(todelete):
 435                             del scores[todelete]
 436                             self.save_scores(scores)
 437                             serv.privmsg(auteur,"Score de %s supprimé"%(todelete))
 438                         else:
 439                             serv.privmsg(auteur,"Ce score n'existe pas : %s"%(todelete))
 440                     else:
 441                         serv.privmsg(auteur,"Syntaxe : SCORES DEL <pseudo>")
 442                 elif souscmd in ["add","sub"]:
 443                     if len(message)==4:
 444                         toadd,val=message[2],message[3]
 445                         try:
 446                             val=int(val)
 447                         except ValueError:
 448                             serv.privmsg(auteur,"Syntaxe : SCORES {ADD|SUB} <pseudo> <n>")
 449                             return
 450                         if souscmd=="sub":
 451                             val=-val
 452                         self.add_score(toadd,val)
 453                         serv.privmsg(auteur,"Done")
 454                     else:
 455                         serv.privmsg(auteur,"Syntaxe : SCORES {ADD|SUB} <pseudo> <n>")
 456                 else:
 457                     serv.privmsg(auteur,"Syntaxe : SCORES {DEL|ADD|SUB} <pseudo> [<n>]")
 458             else:
 459                 notunderstood=True
 460         else:
 461             notunderstood=True
 462         if notunderstood:
 463             serv.privmsg(auteur,"Je n'ai pas compris. Essaye HELP…")
 464
 465     def on_pubmsg(self, serv, ev):
 466         auteur = irclib.nm_to_n(ev.source())
 467         canal = ev.target()
 468         message = ev.arguments()[0]
 469         try:
 470             test=bot_unicode(message)
 471         except UnicodeBotError:
 472             if not canal in self.quiet_channels:
 473                 serv.privmsg(canal,
 474                    "%s: Euh, tu fais de la merde avec ton encodage là, j'ai failli crasher…"%(auteur))
 475             return
 476         tryother=False
 477         pour_moi,message=self.pourmoi(serv,message)
 478         if pour_moi and message.split()!=[]:
 479             cmd=message.split()[0].lower()
 480             try:
 481                 args=" ".join(message.split()[1:])
 482             except:
 483                 args=""
 484             if cmd in ["meurs","die","crève"]:
 485                 if auteur in self.overops:
 486                     self.mourir()
 487                     log(self.serveur,canal,auteur,message+"[successful]")
 488                 else:
 489                     serv.privmsg(canal,"%s: crève !"%(auteur))
 490                     log(self.serveur,canal,auteur,message+"[failed]")
 491             if cmd in ["meur", "meurt","meurre","meurres"] and not canal in self.quiet_channels:
 492                 serv.privmsg(canal,'%s: Mourir, impératif, 2ème personne du singulier : "meurs" (de rien)'%(auteur))
 493             if cmd in ["part","leave","dégage"]:
 494                 if auteur in self.ops and (not (canal in self.stay_channels)
 495                                            or auteur in self.overops):
 496                     self.quitter(canal)
 497                     log(self.serveur,canal,auteur,message+"[successful]")
 498                     self.chanlist.remove(canal)
 499                 else:
 500                     serv.privmsg(canal,"%s: Non, je reste !"%(auteur))
 501                     log(self.serveur,canal,auteur,message+"[failed]")
 502
 503             if cmd in ["deviens","pseudo"]:
 504                 if auteur in self.ops:
 505                     become=args
 506                     serv.nick(become)
 507                     log(self.serveur,canal,auteur,message+"[successful]")
 508             if cmd in ["coucou"] and not canal in self.quiet_channels:
 509                 serv.privmsg(canal,"%s: coucou"%(auteur))
 510             if cmd in ["ping"] and not canal in self.quiet_channels:
 511                 serv.privmsg(canal,"%s: pong"%(auteur))
 512             if cmd in ["date","dates","histoire","énigme","enigme","encore"]:
 513                 if canal in self.play_channels:
 514                     if self.play_status.get(canal,[-1])[0]==0:
 515                         try:
 516                             self.start_enigme(serv,canal)
 517                         except RefuseError:
 518                             serv.privmsg(canal,"%s: Je peux souffler une minute ?"%(auteur))
 519                     else:
 520                         serv.privmsg(canal,("%s: Rappel : %s"%(auteur,self.play_status[canal][2])).encode("utf8") )
 521                 else:
 522                     serv.privmsg(canal,"%s: pas ici…"%(auteur))
 523             if cmd in ["score","!score"]:
 524                 serv.privmsg(auteur,"Votre score : %s"%(self.get_scores().get(auteur,0)) )
 525             if cmd in ["scores","!scores"]:
 526                 scores=self.get_scores().items()
 527                 # trie par score
 528                 scores.sort(lambda x,y:cmp(x[1],y[1]))
 529                 scores.reverse()
 530                 serv.privmsg(auteur,"Scores by score : "+" ; ".join(["%s %s"%(i[0],i[1]) for i in scores]))
 531                 # trie par pseudo
 532                 scores.sort(lambda x,y:cmp(x[0].lower(),y[0].lower()))
 533                 serv.privmsg(auteur,"Scores by pseudo : "+" ; ".join(["%s %s"%(i[0],i[1]) for i in scores]))
 534             if cmd=="indice" and canal in self.play_channels:
 535                 self.give_indice(serv,canal,None)
 536             if is_tag(message) and not canal in self.quiet_channels:
 537                 if auteur in self.ops:
 538                     action=random.choice(config_tag_actions)
 539                     serv.action(canal,action.encode("utf8"))
 540                     self.quiet_channels.append(canal)
 541                 else:
 542                     answer=random.choice(config_tag_answers)
 543                     for ligne in answer.split("\n"):
 544                         serv.privmsg(canal,"%s: %s"%(auteur,ligne.encode("utf8")))
 545             else:
 546                 tryother=True
 547         else:
 548             tryother=True
 549         if tryother:
 550             if self.play_status.get(canal,[-1])[0] in [1,2]:
 551                 answer=self.play_status[canal][1]
 552                 if reussi(message.decode("utf8"),answer,auteur):
 553                     serv.privmsg(canal,(u"%s: bravo ! (C'était le %s)"%(auteur,answer)).encode("utf8"))
 554                     log(self.serveur,canal,auteur+"$win",message)
 555                     self.add_score(auteur,1)
 556                     token=time.time()
 557                     self.play_status[canal]=[0,token]
 558                     serv.execute_delayed(random.randrange(Ttrig*5,Ttrig*10),self.start_enigme,(serv,canal,token))
 559
 560     def on_kick(self,serv,ev):
 561         auteur = irclib.nm_to_n(ev.source())
 562         channel = ev.target()
 563         victime = ev.arguments()[0]
 564         raison = ev.arguments()[1]
 565         if victime==self.nick:
 566             log(self.serveur,"%s kické par %s (raison : %s)" %(victime,auteur,raison))
 567             time.sleep(5)
 568             serv.join(channel)
 569             # on ne dit rien au rejoin
 570             #l1,l2=config_kick_answers,config_kick_actions
 571             #n1,n2=len(l1),len(l2)
 572             #i=random.randrange(n1+n2)
 573             #if i>=n1:
 574             #    serv.action(channel,l2[i-n1].format(auteur).encode("utf8"))
 575             #else:
 576             #    serv.privmsg(channel,l1[i].format(auteur).encode("utf8"))
 577
 578     def quitter(self,chan,leave_message=None):
 579         if leave_message==None:
 580             leave_message=random.choice(config_leave_messages)
 581         try:
 582             leave_message=leave_message%(time.strftime("le %d/%m/%Y à %T").decode("utf8"),self.nick)
 583         except:
 584             pass
 585         self.serv.part(chan,message=leave_message.encode("utf8"))
 586
 587     def mourir(self):
 588         quit_message=random.choice(config_quit_messages)
 589         try:
 590             quit_message=quit_message%(time.strftime("le %d/%m/%Y à %T").decode("utf8"),self.nick)
 591         except:
 592             pass
 593         self.die(msg=quit_message.encode("utf8"))
 594
 595     def get_scores(self):
 596         f=open(config_score_file)
 597         scores=pickle.load(f)
 598         f.close()
 599         return scores
 600
 601     def add_score(self,pseudo,value):
 602         scores=self.get_scores()
 603         if scores.has_key(pseudo):
 604             scores[pseudo]+=value
 605         else:
 606             scores[pseudo]=value
 607         self.save_scores(scores)
 608
 609     def save_scores(self,scores):
 610         f=open(config_score_file,"w")
 611         pickle.dump(scores,f)
 612         f.close()
 613
 614     def _getnick(self):
 615         return self.serv.get_nickname()
 616     nick = property(_getnick)
 617
 618 if __name__=="__main__":
 619     import sys
 620     if len(sys.argv)==1:
 621         print "Usage : deconnaisseur.py <serveur> [--debug]"
 622         exit(1)
 623     serveur=sys.argv[1]
 624     if "debug" in sys.argv or "--debug" in sys.argv:
 625         debug=True
 626     else:
 627         debug=False
 628     serveurs={"a♡":"acoeur.crans.org","acoeur":"acoeur.crans.org","acoeur.crans.org":"acoeur.crans.org",
 629               "irc":"irc.crans.org","crans":"irc.crans.org","irc.crans.org":"irc.crans.org"}
 630     try:
 631         serveur=serveurs[serveur]
 632     except KeyError:
 633         print "Server Unknown : %s"%(serveur)
 634         exit(404)
 635     deco=Deconnaisseur(serveur,debug)
 636     deco.start()