saturnin.py

   1 #!/usr/bin/python
   2 # -*- encoding: utf-8 -*-
   3
   4 # Codé par 20-100
   5
   6 # Un bot IRC pour remplacer le canard.
   7 # parce que le canard, c'est le bien et que braice ne pong pas
   8
   9 import irclib
  10 import ircbot
  11 import threading
  12 import random
  13 import time
  14 import socket, ssl, json
  15 import pickle
  16 import re
  17 import os
  18 from commands import getstatusoutput as ex
  19
  20 # on récupère la config
  21 import config
  22
  23
  24
  25 def get_config_logfile(serveur):
  26     serveurs={"acoeur.crans.org":"acoeur","irc.crans.org":"crans"}
  27     return config.logfile_template%(serveurs[serveur])
  28
  29 def log(serveur,channel,auteur=None,message=None):
  30     f=open(get_config_logfile(serveur),"a")
  31     if auteur==message==None:
  32         # alors c'est que c'est pas un channel mais juste une ligne de log
  33         chain="%s %s"%(time.strftime("%F %T"),channel)
  34     else:
  35         chain="%s [%s:%s] %s"%(time.strftime("%F %T"),channel,auteur,message)
  36     f.write(chain+"\n")
  37     if config.debug_stdout:
  38         print chain
  39     f.close()
  40
  41 def is_something(chain,matches,avant=u".*(?:^| )",apres=u"(?:$|\.| |,|;).*",case_sensitive=False,debug=False):
  42     if case_sensitive:
  43         chain=unicode(chain,"utf8")
  44     else:
  45         chain=unicode(chain,"utf8").lower()
  46     allmatches="("+"|".join(matches)+")"
  47     reg=(avant+allmatches+apres).lower()
  48     o=re.match(reg,chain)
  49     return o
  50
  51 regexp_pan = re.compile(u".*(" + "|".join(config.killwords) + u").*")
  52 def is_pan(chain):
  53     return regexp_pan.match(unicode(chain,"utf8").lower())
  54
  55 class UnicodeBotError(Exception):
  56     pass
  57 def bot_unicode(chain):
  58     try:
  59         unicode(chain,"utf8")
  60     except UnicodeDecodeError as exc:
  61         raise UnicodeBotError
  62
  63 class Saturnin(ircbot.SingleServerIRCBot):
  64     def __init__(self,serveur,debug=False):
  65         temporary_pseudo=config.irc_pseudo+str(random.randrange(10000,100000))
  66         ircbot.SingleServerIRCBot.__init__(self, [(serveur, 6667)],
  67                               temporary_pseudo,"Coin ? ©braice [mais 'faut frapper 20-100]", 10)
  68         self.debug=debug
  69         self.serveur=serveur
  70         self.overops=config.overops
  71         self.ops=self.overops+config.ops
  72         self.chanlist=config.chanlist
  73         self.stay_channels=config.stay_channels
  74         self.quiet_channels=config.quiet_channels
  75         self.play_channels=config.play_channels
  76         self.status = { chan : [0, None] for chan in self.play_channels }
  77         # 0 : pas de spawn prévu
  78         # 1 : un spawn prévu,
  79         #     avec en deuxième paramètre le timestamp du moment où il a été déclenché (pas du moment où il se fera)
  80         # 2 : alive
  81         self.last_perdu=0
  82
  83     def give_me_my_pseudo(self,serv):
  84         serv.privmsg("NickServ","RECOVER %s %s"%(config.irc_pseudo,config.irc_password))
  85         serv.privmsg("NickServ","RELEASE %s %s"%(config.irc_pseudo,config.irc_password))
  86         time.sleep(0.3)
  87         serv.nick(config.irc_pseudo)
  88
  89     def on_welcome(self, serv, ev):
  90         self.serv=serv # ça serv ira :)
  91         self.give_me_my_pseudo(serv)
  92         serv.privmsg("NickServ","IDENTIFY %s"%(config.irc_password))
  93         log(self.serveur,"Connected")
  94         if self.debug:
  95             self.chanlist = self.play_channels = ["#bot"]
  96             self.status = { chan : [0, 0] for chan in self.play_channels }
  97         for c in self.chanlist:
  98             log(self.serveur,"JOIN %s"%(c))
  99             serv.join(c)
 100             if c in self.play_channels:
 101                 spawn_delay = random.randrange(*config.spawn_delays)
 102                 self.spawn(c, time.time(), spawn_delay)
 103
 104     def pourmoi(self, serv, message):
 105         """renvoie (False,lemessage) ou (True, le message amputé de "pseudo: ")"""
 106         pseudo=self.nick
 107         size=len(pseudo)
 108         if message[:size]==pseudo and len(message)>size and message[size]==":":
 109             return (True,message[size+1:].lstrip(" "))
 110         else:
 111             return (False,message)
 112
 113     def on_privmsg(self, serv, ev):
 114         message=ev.arguments()[0]
 115         auteur = irclib.nm_to_n(ev.source())
 116         try:
 117             test=bot_unicode(message)
 118         except UnicodeBotError:
 119             if config.utf8_trigger:
 120                 serv.privmsg(auteur, random.choice(config.utf8_fail_answers).encode("utf8"))
 121             return
 122         message=message.split()
 123         cmd=message[0].lower()
 124         notunderstood=False
 125         if cmd=="help":
 126             helpdico={"help":["""HELP <commande>
 127  Affiche de l'aide sur la commande""",None,None],
 128  "score":["""SCORE
 129  Affiche votre score""", None, None],
 130  "scores":["""SCORES
 131  Afficher tous les scores""", None, None],
 132  "join": [None, """JOIN <channel>
 133  Me fait rejoindre le channel""",None],
 134  "leave": [None,"""LEAVE <channel>
 135  Me fait quitter le channel (sauf s'il est dans ma stay_list).""",None],
 136  "quiet": [None,"""QUIET <channel>
 137  Me rend silencieux sur le channel.""",None],
 138  "noquiet": [None,"""NOQUIET <channel>
 139  Me rend la parole sur le channel.""",None],
 140  "play": [None, """PLAY
 141  Passe un channel en mode "jouer" """,None],
 142  "noplay": [None, """NOPLAY
 143  Passe un channel en mode "ne pas jouer" """,None],
 144  "SPAWN": [None, """SPAWN <channel>
 145  Me fait spawner sur le channel.""",None],
 146  "reload": [None,"""RELOAD
 147  Recharge la configuration.""",None],
 148  "say": [None,None,"""SAY <channel> <message>
 149  Me fait parler sur le channel."""],
 150  "do": [None,None,"""DO <channel> <action>
 151  Me fait faitre une action (/me) sur le channel."""],
 152  "stay": [None,None,"""STAY <channel>
 153  Ajoute le channel à ma stay_list."""],
 154  "nostay": [None,None,"""NOSTAY <channel>
 155  Retire le channel de ma stay_list."""],
 156  "ops": [None,None,"""OPS
 157  Affiche la liste des ops."""],
 158  "overops": [None,None,"""OVEROPS
 159  Affiche la liste des overops."""],
 160  "kick": [None,None,"""KICK <channel> <pseudo> [<raison>]
 161  Kicke <pseudo> du channel (Il faut bien entendu que j'y sois op)."""],
 162  "die": [None,None,"""DIE
 163  Me déconnecte du serveur IRC."""]
 164  }
 165             helpmsg_default="Liste des commandes disponibles :\nHELP SCORE SCORES"
 166             helpmsg_ops=" JOIN LEAVE QUIET NOQUIET PLAY NOPLAY SPAWN"
 167             helpmsg_overops=" SAY DO STAY NOSTAY OPS OVEROPS KICK DIE"
 168             op,overop=auteur in self.ops, auteur in self.overops
 169             if len(message)==1:
 170                 helpmsg=helpmsg_default
 171                 if op:
 172                     helpmsg+=helpmsg_ops
 173                 if overop:
 174                     helpmsg+=helpmsg_overops
 175             else:
 176                 helpmsgs=helpdico.get(message[1].lower(),["Commande inconnue.",None,None])
 177                 helpmsg=helpmsgs[0]
 178                 if op and helpmsgs[1]:
 179                     if helpmsg:
 180                         helpmsg+="\n"+helpmsgs[1]
 181                     else:
 182                         helpmsg=helpmsgs[1]
 183                 if overop and helpmsgs[2]:
 184                     if helpmsg:
 185                         helpmsg+="\n"+helpmsgs[2]
 186                     else:
 187                         helpmsg=helpmsgs[2]
 188             for ligne in helpmsg.split("\n"):
 189                 serv.privmsg(auteur,ligne)
 190         elif cmd=="join":
 191             if auteur in self.ops:
 192                 if len(message)>1:
 193                     if message[1] in self.chanlist:
 194                         serv.privmsg(auteur,"Je suis déjà sur %s"%(message[1]))
 195                     else:
 196                         serv.join(message[1])
 197                         self.chanlist.append(message[1])
 198                         serv.privmsg(auteur,"Channels : "+" ".join(self.chanlist))
 199                         log(self.serveur,"priv",auteur," ".join(message))
 200                 else:
 201                     serv.privmsg(auteur,"Channels : "+" ".join(self.chanlist))
 202             else:
 203                 notunderstood=True
 204         elif cmd=="leave":
 205             if auteur in self.ops and len(message)>1:
 206                 if message[1] in self.chanlist:
 207                     if not (message[1] in self.stay_channels) or auteur in self.overops:
 208                         self.quitter(message[1]," ".join(message[2:]))
 209                         self.chanlist.remove(message[1])
 210                         log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 211                     else:
 212                         serv.privmsg(auteur,"Non, je reste !")
 213                         log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 214                 else:
 215                     serv.privmsg(auteur,"Je ne suis pas sur %s"%(message[1]))
 216             else:
 217                 notunderstood=True
 218         elif cmd=="stay":
 219             if auteur in self.overops:
 220                 if len(message)>1:
 221                     if message[1] in self.stay_channels:
 222                         log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 223                         serv.privmsg(auteur,"Je stay déjà sur %s."%(message[1]))
 224                     else:
 225                         log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 226                         self.stay_channels.append(message[1])
 227                         serv.privmsg(auteur,"Stay channels : "+" ".join(self.stay_channels))
 228                 else:
 229                     serv.privmsg(auteur,"Stay channels : "+" ".join(self.stay_channels))
 230             else:
 231                 notunderstood=True
 232         elif cmd=="nostay":
 233             if auteur in self.overops:
 234                 if len(message)>1:
 235                     if message[1] in self.stay_channels:
 236                         log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 237                         self.stay_channels.remove(message[1])
 238                         serv.privmsg(auteur,"Stay channels : "+" ".join(self.stay_channels))
 239                     else:
 240                         log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 241                         serv.privmsg(auteur,"Je ne stay pas sur %s."%(message[1]))
 242
 243             else:
 244                 notunderstood=True
 245         elif cmd=="die":
 246             if auteur in self.overops:
 247                 log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 248                 self.mourir()
 249             else:
 250                 notunderstood=True
 251         elif cmd=="quiet":
 252             if auteur in self.ops:
 253                 if len(message)>1:
 254                     if message[1] in self.quiet_channels:
 255                         serv.privmsg(auteur,"Je me la ferme déjà sur %s"%(message[1]))
 256                         log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 257                     else:
 258                         self.quiet_channels.append(message[1])
 259                         serv.privmsg(auteur,"Quiet channels : "+" ".join(self.quiet_channels))
 260                         log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 261                 else:
 262                     serv.privmsg(auteur,"Quiet channels : "+" ".join(self.quiet_channels))
 263             else:
 264                 notunderstood=True
 265         elif cmd=="noquiet":
 266             if auteur in self.ops:
 267                 if len(message)>1:
 268                     if message[1] in self.quiet_channels:
 269                         self.quiet_channels.remove(message[1])
 270                         serv.privmsg(auteur,"Quiet channels : "+" ".join(self.quiet_channels))
 271                         log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 272                     else:
 273                         serv.privmsg(auteur,"Je ne me la ferme pas sur %s."%(message[1]))
 274                         log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 275             else:
 276                 notunderstood=True
 277         elif cmd=="play":
 278             if auteur in self.ops:
 279                 if len(message)>1:
 280                     if message[1] in self.play_channels:
 281                         serv.privmsg(auteur,"Je play déjà sur %s."%(message[1]))
 282                         log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 283                     else:
 284                         self.play_channels.append(message[1])
 285                         self.spawn(message[1], 1)
 286                         serv.privmsg(auteur,"Play channels : "+" ".join(self.play_channels))
 287                         log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 288                 else:
 289                     serv.privmsg(auteur,"Play channels : "+" ".join(self.play_channels))
 290             else:
 291                 notunderstood=True
 292         elif cmd=="noplay":
 293             if auteur in self.ops:
 294                 if len(message)>1:
 295                     if message[1] in self.play_channels:
 296                         self.play_channels.remove(message[1])
 297                         serv.privmsg(auteur,"Play channels : "+" ".join(self.play_channels))
 298                         log(self.serveur,"priv",auteur," ".join(message)+"[successful]")
 299                     else:
 300                         serv.privmsg(auteur,"Je ne play pas sur %s."%(message[1]))
 301                         log(self.serveur,"priv",auteur," ".join(message)+"[failed]")
 302             else:
 303                 notunderstood=True
 304         elif cmd=="spawn":
 305             if auteur in self.ops:
 306                 if len(message)>1:
 307                     if message[1] in self.play_channels:
 308                         # Le plus pratique pour pas s'embêter c'est de mettre un
 309                         #  delay d'une seconde, comme ça .spawn() fait le boulot
 310                         self.spawn(message[1], time.time(), 1)
 311                     else:
 312                         serv.privmsg(auteur, "Je ne joue pas sur %s" % message[1])
 313                 else:
 314                     serv.privmsg(auteur, "Syntaxe : SPAWN <channel>")
 315             else:
 316                 notunderstood=True
 317         elif cmd=="say":
 318             if auteur in self.overops and len(message)>2:
 319                 serv.privmsg(message[1]," ".join(message[2:]))
 320                 log(self.serveur,"priv",auteur," ".join(message))
 321             elif len(message)<=2:
 322                 serv.privmsg(auteur,"Syntaxe : SAY <channel> <message>")
 323             else:
 324                 notunderstood=True
 325         elif cmd=="do":
 326             if auteur in self.overops and len(message)>2:
 327                 serv.action(message[1]," ".join(message[2:]))
 328                 log(self.serveur,"priv",auteur," ".join(message))
 329             elif len(message)<=2:
 330                 serv.privmsg(auteur,"Syntaxe : DO <channel> <action>")
 331             else:
 332                 notunderstood=True
 333         elif cmd=="kick":
 334             if auteur in self.overops and len(message)>2:
 335                 serv.kick(message[1],message[2]," ".join(message[3:]))
 336                 log(self.serveur,"priv",auteur," ".join(message))
 337             elif len(message)<=2:
 338                 serv.privmsg(auteur,"Syntaxe : KICK <channel> <pseudo> [<raison>]")
 339             else:
 340                 notunderstood=True
 341         elif cmd=="ops":
 342             if auteur in self.overops:
 343                 serv.privmsg(auteur," ".join(self.ops))
 344             else:
 345                 notunderstood=True
 346         elif cmd=="overops":
 347             if auteur in self.overops:
 348                 serv.privmsg(auteur," ".join(self.overops))
 349             else:
 350                 notunderstood=True
 351         elif cmd=="reload":
 352             if auteur in self.ops:
 353                 reload(config)
 354                 serv.privmsg(auteur,"done")
 355             else:
 356                 notunderstood=True
 357         elif cmd=="score":
 358             if len(message)>1:
 359                 if len(message) in [3,4] and message[1].lower()=="transfert":
 360                     scores=self.get_scores()
 361                     de,to=auteur,message[2]
 362                     value=scores.get(de,0)
 363                     if len(message)==4:
 364                         try:
 365                             asked=int(message[3])
 366                         except ValueError:
 367                             serv.privmsg(auteur,"Syntaxe : SCORE TRANSFERT <pseudo> [<n>]")
 368                             return
 369                     else:
 370                         asked=value
 371                     if value==0:
 372                         serv.privmsg(auteur,"Vous n'avez pas de points")
 373                         return
 374                     elif asked<=0:
 375                         serv.privmsg(auteur,"Bien tenté…")
 376                         return
 377                     elif asked>value:
 378                         serv.privmsg(auteur,"Vous n'avez que %s points"%(value))
 379                         return
 380                     else:
 381                         self.add_score(de,-asked)
 382                         self.add_score(to,asked)
 383                         serv.privmsg(auteur,"Transfert de %s points de %s à %s"%(asked,de,to))
 384                 else:
 385                     serv.privmsg(auteur,"Syntaxe : SCORE TRANSFERT <pseudo> [<n>]")
 386             else:
 387                 self.sendscore(auteur)
 388         elif cmd=="scores":
 389             if len(message)==1:
 390                 self.sendscores(auteur)
 391             elif auteur in self.overops:
 392                 souscmd=message[1].lower()
 393                 if souscmd=="del":
 394                     if len(message)==3:
 395                         todelete=message[2]
 396                         scores=self.get_scores()
 397                         if scores.has_key(todelete):
 398                             del scores[todelete]
 399                             self.save_scores(scores)
 400                             serv.privmsg(auteur,"Score de %s supprimé"%(todelete))
 401                         else:
 402                             serv.privmsg(auteur,"Ce score n'existe pas : %s"%(todelete))
 403                     else:
 404                         serv.privmsg(auteur,"Syntaxe : SCORES DEL <pseudo>")
 405                 elif souscmd in ["add","sub"]:
 406                     if len(message)==4:
 407                         toadd,val=message[2],message[3]
 408                         try:
 409                             val=int(val)
 410                         except ValueError:
 411                             serv.privmsg(auteur,"Syntaxe : SCORES {ADD|SUB} <pseudo> <n>")
 412                             return
 413                         if souscmd=="sub":
 414                             val=-val
 415                         self.add_score(toadd,val)
 416                         serv.privmsg(auteur,"Done")
 417                     else:
 418                         serv.privmsg(auteur,"Syntaxe : SCORES {ADD|SUB} <pseudo> <n>")
 419                 else:
 420                     serv.privmsg(auteur,"Syntaxe : SCORES {DEL|ADD|SUB} <pseudo> [<n>]")
 421             else:
 422                 notunderstood=True
 423         else:
 424             notunderstood=True
 425         if notunderstood:
 426             serv.privmsg(auteur,"Je n'ai pas compris. Essayez HELP…")
 427
 428     def sendscore(self, to):
 429         self.serv.privmsg(to, "Votre score : %s"%(self.get_scores().get(to,0)) )
 430
 431     def sendscores(self, to):
 432         scores=self.get_scores().items()
 433         # trie par score
 434         scores.sort(lambda x,y:cmp(x[1],y[1]))
 435         scores.reverse()
 436         self.serv.privmsg(to, "Scores by score : "+" ; ".join(["%s %s"%(i[0],i[1]) for i in scores]))
 437         # trie par pseudo
 438         scores.sort(lambda x,y:cmp(x[0].lower(),y[0].lower()))
 439         self.serv.privmsg(to, "Scores by pseudo : "+" ; ".join(["%s %s"%(i[0],i[1]) for i in scores]))
 440
 441     def on_pubmsg(self, serv, ev):
 442         auteur = irclib.nm_to_n(ev.source())
 443         channel = ev.target()
 444         message = ev.arguments()[0]
 445         try:
 446             test=bot_unicode(message)
 447         except UnicodeBotError:
 448             if config.utf8_trigger and not channel in self.quiet_channels:
 449                 serv.privmsg(channel, (u"%s: %s"%(auteur,random.choice(config.utf8_fail_answers))).encode("utf8"))
 450             return
 451         pour_moi,message=self.pourmoi(serv,message)
 452         if pour_moi and message.split()!=[]:
 453             cmd=message.split()[0].lower()
 454             try:
 455                 args=" ".join(message.split()[1:])
 456             except:
 457                 args=""
 458             if cmd in ["meurs","die","crève"]:
 459                 if auteur in self.overops:
 460                     log(self.serveur,channel,auteur,message+"[successful]")
 461                     self.mourir()
 462                 else:
 463                     serv.privmsg(channel,("%s: %s"%(auteur,random.choice(config.quit_fail_messages))).encode("utf8"))
 464                     log(self.serveur,channel,auteur,message+"[failed]")
 465             elif cmd in ["part","leave","dégage","va-t-en","tut'tiresailleurs,c'estmesgalets"]:
 466                 if auteur in self.ops and (not (channel in self.stay_channels)
 467                                            or auteur in self.overops):
 468                     self.quitter(channel)
 469                     log(self.serveur,channel,auteur,message+"[successful]")
 470                     if channel in self.chanlist:
 471                         self.chanlist.remove(channel)
 472                 else:
 473                     serv.privmsg(channel,("%s: %s"%(auteur,random.choice(config.leave_fail_messages))).encode("utf8"))
 474                     log(self.serveur,channel,auteur,message+"[failed]")
 475             elif cmd == "score":
 476                 self.sendscore(auteur)
 477             elif cmd == "scores":
 478                 self.sendscores(auteur)
 479         else:
 480             if is_pan(message):
 481                 self.shot(channel, auteur)
 482
 483     def on_action(self, serv, ev):
 484         action = ev.arguments()[0]
 485         auteur = irclib.nm_to_n(ev.source())
 486         channel = ev.target()
 487         #~ try:
 488             #~ test=bot_unicode(action)
 489         #~ except UnicodeBotError:
 490             #~ if config.utf8_trigger and not channel in self.quiet_channels:
 491                 #~ serv.privmsg(channel, (u"%s: %s"%(auteur,random.choice(config.utf8_fail_answers))).encode("utf8"))
 492             #~ return
 493         #~ mypseudo=self.nick
 494
 495     def on_kick(self,serv,ev):
 496         auteur = irclib.nm_to_n(ev.source())
 497         channel = ev.target()
 498         victime = ev.arguments()[0]
 499         raison = ev.arguments()[1]
 500         if victime==self.nick:
 501             log(self.serveur,"%s kické de %s par %s (raison : %s)" %(victime,channel,auteur,raison))
 502             time.sleep(2)
 503             serv.join(channel)
 504             #~ l1,l2=config.kick_answers,config.kick_actions
 505             #~ n1,n2=len(l1),len(l2)
 506             #~ i=random.randrange(n1+n2)
 507             #~ if i>=n1:
 508                 #~ serv.action(channel,l2[i-n1].format(auteur).encode("utf8"))
 509             #~ else:
 510                 #~ serv.privmsg(channel,l1[i].format(auteur).encode("utf8"))
 511
 512     def spawn(self, channel, timestamp, delay=0):
 513         if channel in self.play_channels:
 514             if delay>0:
 515                 self.serv.execute_delayed(delay, self.spawn, (channel, timestamp))
 516                 self.status[channel] = [1, timestamp]
 517             else:
 518                 # on teste le timestamp pour pas s'emmêler dans les spawn
 519                 infos = self.status.get(channel, [0,0])
 520                 if infos == [1, timestamp]:
 521                     spawn_sentence = random.choice(config.canards) + random.choice(config.spawn_sentences)
 522                     self.serv.privmsg(channel, spawn_sentence.encode("utf8"))
 523                     self.status[channel] = [2, timestamp]
 524                     times_up_delay = random.randrange(*config.times_up_delays)
 525                     self.serv.execute_delayed(times_up_delay, self.too_slow, (channel, timestamp))
 526
 527     def too_slow(self, channel, timestamp):
 528         infos = self.status.get(channel, [0,0])
 529         if infos == [2, timestamp]:
 530             self.serv.privmsg(channel, random.choice(config.times_up_sentences).encode("utf8"))
 531             respawn_delay = random.randrange(*config.spawn_delays)
 532             self.spawn(channel, time.time(), respawn_delay)
 533
 534     def shot(self, channel, auteur):
 535         if self.status.get(channel, [0, 0])[0] == 2:
 536             succeed = random.randrange(0,101) > config.proba_miss
 537             if succeed:
 538                 self.serv.privmsg(channel, random.choice(config.killed_templates).format(auteur).encode("utf8"))
 539                 self.add_score(auteur, 1)
 540                 if random.randrange(0, 101) < config.proba_killed_sentence:
 541                     self.serv.privmsg(channel, random.choice(config.killed_sentences).encode("utf8"))
 542                 respawn_delay = random.randrange(*config.spawn_delays)
 543                 self.spawn(channel, time.time(), respawn_delay)
 544             else:
 545                 self.serv.privmsg(channel, random.choice(config.miss_templates).format(auteur).encode("utf8"))
 546                 if random.randrange(0,101) < config.proba_miss_sentence:
 547                     self.serv.privmsg(channel, random.choice(config.miss_sentences).encode("utf8"))
 548
 549     def quitter(self,chan,leave_message=None):
 550         if leave_message==None:
 551             leave_message=random.choice(config.leave_messages)
 552         self.serv.part(chan,message=leave_message.encode("utf8"))
 553
 554     def mourir(self):
 555         quit_message=random.choice(config.quit_messages)
 556         self.die(msg=quit_message.encode("utf8"))
 557
 558     def get_scores(self):
 559         f=open(config.score_file)
 560         scores=pickle.load(f)
 561         f.close()
 562         return scores
 563
 564     def add_score(self, pseudo, value):
 565         scores=self.get_scores()
 566         if scores.has_key(pseudo):
 567             scores[pseudo]+=value
 568         else:
 569             scores[pseudo]=value
 570         self.save_scores(scores)
 571
 572     def save_scores(self,scores):
 573         f=open(config.score_file,"w")
 574         pickle.dump(scores,f)
 575         f.close()
 576
 577     def _getnick(self):
 578         return self.serv.get_nickname()
 579     nick=property(_getnick)
 580
 581
 582 if __name__=="__main__":
 583     import sys
 584     if len(sys.argv)==1:
 585         print "Usage : saturnin.py <serveur> [--debug]"
 586         exit(1)
 587     serveur=sys.argv[1]
 588     if "debug" in sys.argv or "--debug" in sys.argv:
 589         debug=True
 590     else:
 591         debug=False
 592     if "--quiet" in sys.argv:
 593         config.debug_stdout=False
 594     serveurs={"a♡":"acoeur.crans.org","acoeur":"acoeur.crans.org","acoeur.crans.org":"acoeur.crans.org",
 595               "irc":"irc.crans.org","crans":"irc.crans.org","irc.crans.org":"irc.crans.org"}
 596     try:
 597         serveur=serveurs[serveur]
 598     except KeyError:
 599         print "Server Unknown : %s"%(serveur)
 600         exit(404)
 601     bot = Saturnin(serveur,debug)
 602     bot.start()