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