deconnaisseur.py

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