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