Aide Tcl

Voici une aide sur le langage TCL :

[ Sommaire ]

1. Introduction
2. Le script
3. Les Binds
4. Les Procédures
5. Les Variables
6. Les commandes d'écriture
7. La Condition
8. Les Boucles
9. Retour sur les variables
10. Retour sur notre script
11. Ressources
12. Informations Additionnelles (Flags, Masques)
13. Conclusion

[ I. Introduction ]

Le TCL (Tool Command Language) est un language de script. C'est celui qui permet de programmer des scripts pour les bots Eggdrop. Nous pourrions bien sûr vous faire quinze pages de cours théoriques sur le TCL, mais ce n'est pas ainsi que nous avons appris le TCL, et nous ne sommes pas sûrs que ce soit la meilleure méthode. Nous avons donc choisi de décrire toutes les étapes de la création d'un petit script.

[ II. Le Script ]

Il nous arrive souvent de nous demander ce que signifient les abréviations à la fin des adresses Internet. Si c'est facile pour www.yahoo.fr, ça l'est moins pour astalavista.box.sk.
Le but est donc de faire un script qui répond à !Pays Abréviation sur un channel, à /Msg Nick Du Bot Pays Abréviation en query, ou à /Notice Nick Du Bot Pays Abréviation en notice.
De plus, il doit être possible d'envoyer plusieurs abréviations à la fois, par exemple : !Pays FR BE DE retournera France, Belgique et Allemagne.
Le bot doit aussi vous avertir de l'existence de cette fonction lors de votre arrivée sur le channel. Mais cette information doit pouvoir être désactivée dans la configuration du script.
Cela vous paraît compliqué ? Vous verrez qu'abordé méthodiquement, ce script ne vous posera aucun problème.

[ III. Les Binds ]

C'est la partie la plus théorique de cette initiation. Elle est très importante.
Les binds définissent à quoi le bot doit réagir. À chaque fois qu'il se passe quelque chose, l'Eggdrop vérifie si cette action correspond à un bind. Il existe donc des binds pour tout ce que se passe sur IRC (Join, Part, Quit, Notice, ...).
Un bind se présente sous cette forme :
bind type flag arguments Procédure à appeler
Lorsque l'action définie par le type (Join, Part, Quit, Notice, ...) et les arguments (Channel, Nick, ...) se produit, l'eggdrop vérifie que la personne qui a déclenché le bind a bien les flags nécessaires (voir aussi la section Flags de cette initiation), puis, exécute la procédure.
La liste complète des binds se trouve dans le fichier texte tcl-commands.doc. Ce fichier vous servira très souvent lorsque vous programmez en TCL.

Différence entre MSG et MSGM, et entre PUB et PUBM :
À la première lecture du fichier tcl-commands.doc, PUB et PUBM peuvent vous sembler équivalents. Or ils sont très différents :

• PUB permet de répondre à une commande, qui sera le premier mot de la ligne de texte.
  Il répondra à :
  !Commande texte1 texte2 texte3 texte4
  mais pas à :
  texte1 texte2 !Commande texte3 texte4
  
• PUBM est un bind sur un masque (Voir aussi la section "masques" de cette initiation).
  Par exemple un bind PUBM sur *chaine* répondra aussi bien à "chainetexte1texte2texte3" qu'à "texte1texte2chainetexte3texte4" ou à "texte1texte2texte3chaine".
  
• Les binds PUBM sont empilables (stackable), pas les binds PUB.
  Vous pouvez donc dans vos scripts avoir deux binds PUBM réagissant au même masque (les deux procédures étant alors exécutées l'une après l'autre), mais pas deux bind PUB réagissant à la même commande.

Application à notre script :
Commande sur le channel : bind pub - !pays pub:pays
En /msg : bind msg - pays msg:pays
En /notice : bind notc - pays notc:pays

[ IV. Les Procédures ]

Une procédure est une portion de code qui peut être appelée par n'importe quoi dans un script. On peut aussi en faire des fonctions (lorsqu'elles retournent quelque chose). Pour les eggdrops, la procédure est appelée par un bind.

Syntaxe :
proc nom de la procédure { arguments } { corps de la procédure }

Exemple : Réponse à !Pays
Extrait de tcl-commands.doc :
(1) PUB
(2) bind pub <flags> <command> <proc>
(3) procname <nick> <user@host> <handle> <channel> <arg>
(4) used for commands given on a channel; just like MSG, the first word becomes the command and everything else is the argument string.

1: Nom du bind
2: Syntaxe de la ligne bind (Voir plus haut)
3: Syntaxe de la procédure et liste des arguments passés à celle-ci
4: Explication du bind PUB

Donc :
bind pub - !pays pub:pays
proc pub:pays { nick uhost handle channel arg } {
putserv "PRIVMSG $channel :Réponse à !Pays"
}

Nous verrons plus tard dans le détail l'utilisation de putserv et des variables. Sachez simplement que putserv permet d'envoyer une information au serveur. Ce petit script donnera donc :
<Vous> !Pays
<Eggdrop> Réponse à !Pays

[ V. Les Variables ]

Les variables permettent de stocker des informations dans la mémoire de l'eggdrop.
Par exemple, dans le script :

bind pub - !pays pub:pays
proc pub:pays { nick uhost handle channel arg } {
putserv "PRIVMSG $channel :Réponse à !Pays"
}

nick, uhost, handle, channel et arg sont des variables dont le contenu est donné par le bind. Pour utiliser le contenu d'une variable, il faut précéder son nom par un $.
Exemple : $channel retourne le nom du channel sur lequel s'est passée l'action.

Il existe aussi des variables globales dont le contenu est défini par le bot. Pour les utiliser dans une procédure, il faut signaler au bot que son champ d'action n'est pas limité à la procédure, en lui indiquant au début du corps de la procédure les variables globales à utiliser à l'aide de l'instruction global.

Exemple :
bind pub - !nick pub:nick
proc pub:nick { nick uhost handle channel arg } {
global botnick
putserv "PRIVMSG $channel :Mon nick est $botnick"
}

Résultat :
<Vous> !nick
<Eggdrop> Mon nick est Eggdrop

Autre exemple :
bind pub - !infos pub:infos
proc pub:infos { nick uhost handle channel arg } {
global botnick botname server version numversion uptime server-online lastbindbotname server version numversion uptime server-online lastbind
putserv "PRIVMSG $channel :Mon nick est $botnick"
putserv "PRIVMSG $channel :Mon masque nick!user@host est $botname"
putserv "PRIVMSG $channel :Je suis connecté sur le serveur $server"
putserv "PRIVMSG $channel :Ma version est $version"
putserv "PRIVMSG $channel :Ma version numérique est $numversion"
putserv "PRIVMSG $channel :Le moment en temps 'unix' où j'ai été lancé est $uptime"
putserv "PRIVMSG $channel :Le moment en temps 'unix' où je me suis connecté est ${server-online}"
putserv "PRIVMSG $channel :Le dernier bind activé est $lastbind"
}

Ici, on voit comment mettre plusieurs variables dans la même ligne global.

[ VI. Les commandes d'écriture ]

Il en existe 2 sortes : Celles qui permettent d'écrire sur le serveur, et celles qui permettent d'écrire dans les logs.

Ecrire sur le serveur

Les commandes permettant d'envoyer des informations au serveur sont : putkick, pushmode, putserv, puthelp et putquick.

pushmode permet d'envoyer des modes au serveur, comme une commande /mode.
Ex : pushmode #eggdrop +o Lucas
ou : pushmode #eggdrop +s

putkick permet de kicker quelqu'un d'un channel :
Syntaxe : putkick channel nick1,nick2,nick3,... [raison]
Ex : putkick #eggdrop Laurent "pif paf"

puthelp, putserv et putquick permettent d'envoyer toutes les autres commandes au serveur, en utilisant les RAW IRC. La différence entre ces trois commandes est les queues.
Chaque commande utilise une queue différente. putquick est prioritaire par rapport aux deux autres, et putserv est prioritaire par rapport à puthelp.
Chaque ligne envoyée avec une de ces trois commandes est stockée, puis envoyée après un certain délais pour ne pas que l'eggdrop floode le serveur. La file d'attente de putquick est vidée en premier, puis celle de putserv, puis celle de puthelp.
Il faut donc utiliser putquick pour les actions qui doivent se faire très rapidement, putserv pour les actions normales, et puthelp pour les actions qui peuvent attendre (envoi d'une aide à un utilisateur, par exemple).

syntaxe de quelques commandes RAW : (putX représente putquick, putserv ou puthelp)
message en 'query' : putX "PRIVMSG nick :message" (ne pas oublier les :)
message sur un 'channel' : putX "PRIVMSG #channel :message"
notice à une personne : putX "NOTICE nick :message"
notice à un channel : putX "NOTICE nick :message"

Ecrire dans les logs

Les commandes permettant d'écrire dans les logs sont : putlog, putcmdlog, putxferlog et putloglev.
putlog, putcmdlog et putxferlog ont la même syntaxe, et écrivent respectivement dans les logs comme 'misc' (o), 'command' (c) et 'file-area' (x).
Syntaxe :
putXlog "texte"

putloglev a une syntaxe différente :
putloglev "level(s)" "channel" "texte"
Cette commande permet de logger dans un fichier spécifique, et d'attacher ce qui est loggé à un channel.

Ex :
putlog "blah"
loggera "blah" comme information de type 'misc' (o)

Ces commandes sont bien sûr étroitement liées aux commandes 'logfile' du fichier de configuration. Jetez un coup d'oeil à la section 'LOG FILES' de 'eggdrop.conf.dist' pour plus d'informations.

[ VII. La Condition (if et switch) ]

L'utilisation du "if" permet d'exécuter certaines commandes de manière conditionnelle, c'est-à-dire seulement dans certains cas. La syntaxe la plus simple du if est :
if expression commandes
Les commandes sont exécutées si l'expression est vraie.
Une expression est vraie, si la valeur de celle-ci (qui peut être donnée par une fonction, par exemple) est différente de 0. Une expression est fausse si la valeur de celle-ci est 0.

Syntaxe 1 : if expression commandes

bind pub - !isop pub:isop
proc pub:isop { nick uhost handle channel arg } {
if [isop $nick $channel] {
   putserv "PRIVMSG $channel :Tu es opérateur de $channel."
   puthelp "NOTICE $nick :Tu es opérateur de $channel."
}
}

Ce script, vous confirme votre statut d'opérateur sur le channel (Seulement si vous êtes opérateur).

isop est une fonction. Voici sa description dans tcl-commands.doc :
isop <nickname> <channel>
returns: "1" if someone by that nickname is on the channel and has chop; "0" otherwise

Syntaxe 2 : if expression commandes1 else commandes2

bind pub - !isop pub:isop
proc pub:isop { nick uhost handle channel arg } {
if [isop $nick $channel] {
   putserv "PRIVMSG $channel :Tu es opérateur de $channel."
   puthelp "NOTICE $nick :Tu es opérateur de $channel."
} else {
   putserv "PRIVMSG $channel :Tu n'es pas opérateur de $channel."
   puthelp "NOTICE $nick :Tu n'es pas opérateur de $channel."
}
}

Ce script, vous confirme votre statut d'opérateur sur le channel (Si vous n'êtes pas opérateur, il vous le précise aussi).

Si l'expression du "if" n'est pas vraie, alors les commandes qui suivent le "else" sont exécutées.

Syntaxe 3 : if expression1 commandes1 elseif expression2 commandes2 elseif expression3 commandes3 else commandes4

bind pub - !isop pub:isop
proc pub:isop { nick uhost handle channel arg } {
if [isop $nick $channel] {
   putserv "PRIVMSG $channel :Tu es opérateur de $channel."
   puthelp "NOTICE $nick :Tu es opérateur de $channel."
} elseif [isvoice $nick $channel] {
   putserv "PRIVMSG $channel :Tu n'es pas opérateur, mais tu es voice de $channel."
   puthelp "NOTICE $nick :Tu n'es pas opérateur, mais tu es voice de $channel."
} else {
   putserv "PRIVMSG $channel :Tu n'es ni opérateur, ni voice sur $channel."
   puthelp "NOTICE $nick :Tu n'es ni opérateur, ni voice sur $channel."
}
}

Si l'expression qui suit le "if" n'est pas vraie, l'eggdrop regarde si l'expression qui suit le "elseif" est vraie. Si elle est vraie, les commandes qui suivent le "elseif" sont exécutées. Sinon, l'eggdrop examine le "elseif" suivant ou passe au "else".

switch

switch permet d'étudier plusieurs cas. Mais comme on peut faire la même chose avec des "if"-"elseif", nous ne détaillerons pas son utilisation ici.

[ VIII. Les Boucles ]

Les boucles permettent de contrôler l'exécution de votre script, en répétant certaines instructions.
Il y a trois boucles différentes en TCL : for, while et foreach.

While

Cette instruction exécute un groupe d'instruction tant qu'une condition est vraie.
Syntaxe :
while condition instructions
Exemple :
# met la variable x à 0 (zéro)
set x 0
# tant que x est inférieur à 5, exécuter ...
while {$x<5} {
   # écrire dans les logs "x = valeur_de_x"
   putlog "x = $x"
   # incrémenter x
   incr x
}

Voici le résultat de ce script :
<Lucas> .tcl source script.tcl
<Id10tB0t> x = 0
<Id10tB0t> x = 1
<Id10tB0t> x = 2
<Id10tB0t> x = 3
<Id10tB0t> x = 4
<Id10tB0t> Tcl:

For

for est similaire à l'instruction for du C.
Syntaxe :
for début test suivant instructions
Les arguments début, suivant et instructions sont des instructions TCL. test est une expression.
La commande for commence par exécuter l'instruction début. Puis il évalue test d'une manière répétée. Si le résultat est non-nul, il éxécute instructions, puis suivant, puis ré-évalue test, et ainsi de suite. La commande for se termine donc quand le résultat de l'évaluation de test est nul.
Si une commande continue est exécutée à l'intérieur de instructions, alors toutes les commandes restant à éxécuter dans instructions sont sautées, et le processus continue en éxécutant suivant, puis test, et ainsi de suite.
Si une commande break est exécutée à l'intérieur de instructions ou suivant, alors l'instruction for se termine immédiatement.
Cela vous parait sûrement assez compliqué, mais ça l'est bien moins dans la pratique.
Exemple :
Ce script a le même effet que celui servant d'exemple à while.
for {set x 0} {$x<5} {incr x} {
   putlog "x = $x"
}
Voici l'ordre dans lequel les commandes sont exécutées :

set x 0
test si $x<5 ==> retourne 1
putlog "x = 0"
incr x (x a pour valeur 1)
test si $x<5 ==> retourne 1
putlog "x = 1"
incr x (x a pour valeur 2)
test si $x<5 ==> retourne 1
putlog "x = 2"
incr x (x a pour valeur 3)
test si $x<5 ==> retourne 1
putlog "x = 3"
incr x (x a pour valeur 4)
test si $x<5 ==> retourne 1
putlog "x = 4"
incr x (x a pour valeur 5)
test si $x<5 ==> retourne 0, l'exécution de l'instruction for s'arrête.

Résultat de ce script :
<Lucas> .tcl source script.tcl
<Id10tB0t> x = 0
<Id10tB0t> x = 1
<Id10tB0t> x = 2
<Id10tB0t> x = 3
<Id10tB0t> x = 4
<Id10tB0t> Tcl:

[ IX. Retour sur les variables ]

Vous savez (normalement) maintenant manipuler les boucles. La principale utilisation des boucles est la lecture ou l'écriture de tableaux et de listes.

Les tableaux

Les tableaux sont gérés très facilement en TCL.
Syntaxe :
le nom d'une variable faisant partie d'un tableau s'écrit de cette manière : nomdutableau(index).
index peut être un nombre, ou une chaine de caractères.
Exemples :
set nick(1) "Laurent"
set nick(2) "Lucas"
for {set index 1} {$index<=2} {incr index} {
putlog "Nick numéro $index : $nick($index)"
}

Résultat :
<Lucas> .tcl source script.tcl
<Id10tB0t> Nickname numéro 1 : Laurent
<Id10tB0t> Nickname numéro 2 : Lucas
<Id10tB0t> Tcl:

Exemples avec un index en chaîne de caractères :
set IsTheBest(NESS) 1
set QI(Lucas) 150

Les listes

Les listes sont une autre manière de manipuler des données.
Une liste s'écrit sous la forme suivante : { texte1 texte2 texte3 }
Exemple :
Si vous cherchez dans tcl-commands.doc de l'aide sur l'instruction channels, vous trouverez ceci :
channels
returns: list of the channels the bot is monitoring (or trying to)
<Lucas> .tcl channels
<Id10tB0t> Tcl: #chan #chan1 #chan2 #chan3 #chan4 #chan5 #chan6 #chan7 #chan8 #chan9
<Lucas> .status
<Id10tB0t> #Lucas# status
<Id10tB0t> I am Id10tB0t, running eggdrop v1.4.2: 1 user (mem: 91k)
<Id10tB0t> Running on CYGWIN_NT-4.0 20.1 (0.3/1/1)
<Id10tB0t> Admin: Lucas <email: Lucas@Eggdrop-FR.Org>
<Id10tB0t> En ligne depuis 00:26 (mode status) CPU 00:00 cache hit 13.0%
<Id10tB0t> Utilisation de la librairie TCL: C:/library
<Id10tB0t> Channels: #chan, #chan1, #chan2, #chan3, #chan4, #chan5, #chan6,
<Id10tB0t> #chan7, #chan8, #chan9

Instructions de gestion des listes :
Ces instructions ne sont pas détaillées. Pour plus d'informations, consultez le site Scriptics.
list : crée une liste
join : crée une liste
lappend : ajoute des éléments à une liste
lindex : lis un élément d'une liste
linsert : insère des éléments dans une liste
llength : retourne le nombre d'éléments d'une liste
lrange : retourne un ou plusieurs éléments d'une liste
lreplace : remplace des éléments d'une liste
lsearch : recherche un élément dans une liste
lsort : trie les éléments d'une liste

Exemple :
# met la liste des channels dans listedeschans
set listedeschans [channels]
# trie la liste
set listedeschanstriee [lsort $listedeschans]
# affiche les channels sur lequel le bot est :
putlog "Je suis sur ces channels :"
for {set index 0} {$index<[llength $listedeschanstriee]} {incr index} {
putlog "[expr $index + 1]. [lindex $listedeschanstriee $index]"
}

Résultat :
<Lucas> .tcl source script.tcl
<Id10tB0t> Je suis sur ces channels :
<Id10tB0t> 1. #chan
<Id10tB0t> 2. #chan1
[...]
<Id10tB0t> 10. #chan9
<Id10tB0t> Tcl:

[ X. Retour sur notre script ]

Pour stocker la liste des extensions des adresses, nous allons utiliser un tableau :
set pays(be) "Belgique"
ce qui permettra de passer de l'extension au pays en faisant $pays($extension).
Pour simplifier le script, on n'utilisera qu'une dizaine d'extensions/pays.
set pays(be) "Belgique"
set pays(ca) "Canada"
set pays(de) "Allemagne"
set pays(fr) "France"
set pays(sk) "Slovaquie"
set pays(uk) "Royaume-Uni"
set pays(com) "Commercial"
set pays(edu) "Education"
set pays(gov) "Gouvernement"
set pays(mil) "Militaire"
set pays(net) "Réseau"
set pays(org) "Organisation à but non lucratif"

Premier essai :
### pays1.tcl par Lucas

# Binds
bind pub - !pays pub:pays
bind msg - pays msg:pays
bind notc - pays notc:pays

# Données
set pays(be) "Belgique"
set pays(ca) "Canada"
set pays(de) "Allemagne"
set pays(fr) "France"
set pays(sk) "Slovaquie"
set pays(uk) "Royaume-Uni"
set pays(com) "Commercial"
set pays(edu) "Education"
set pays(gov) "Gouvernement"
set pays(mil) "Militaire"
set pays(net) "Réseau"
set pays(org) "Organisation à but non lucratif"

# Procédures
proc pub:pays { nick uhost handle channel arg } {
global pays
putserv "PRIVMSG $channel :$arg signifie $pays($arg)"
}

proc msg:pays { nick uhost handle arg } {
global pays
putserv "PRIVMSG $nick :$arg signifie $pays($arg)"
}

proc notc:pays { nick uhost handle arg } {
global pays
putserv "NOTICE $nick :$arg signifie $pays($arg)"
}

# Fin du script

Ce script est bien sûr très loin de satisfaire notre cahier des charges initial. Voici une liste des choses à changer :

1. Le bot doit pouvoir répondre indifféremment à "!pays be", "!pays Be", "!pays BE", etc...
2. Le bot doit répondre en disant : "BE signifie ...." et non "be signifie ..." (extension en majuscules)
3. Le bot doit avertir quand il ne connait pas l'extension, et non faire une erreur.
4. Le bot doit avertir que ce script existe lors du join.
5. Le bot doit pouvoir analyser des demandes comme "!Pays FR BE DE"

Nous allons tout d'abord nous occuper des 4 premières modifications.

1. il existe une fonction mettant en minuscules. il s'agit de string tolower.
   ex :
   <Lucas> .tcl string tolower AbC
   <Id10tB0t> Tcl: abc
   
2. Il existe aussi une fonction mettant en majuscules. Il s'agit de string toupper.
   
3. Ceci peut être fait avec un petit script très simple :
   bind join - * join:pays
   proc join:pays { nick uhost hand chan } {
   putserv "NOTICE $nick :Un script très pratique est disponible sur $chan. Tapez '!Pays <extension>' pour savoir à quel pays correspond une extension."
   }
4. Cela peut être fait à l'aide de la commande info exists :
   Exemple :
   if [info exists pays($arg)] {
      putserv "PRIVMSG $channel :$arg signifie $pays($arg)"
   } else {
      putserv "PRIVMSG $channel :$arg n'est pas une extension connue."
   }
   

Voici ce que deviendrait notre script, une fois toutes ces modifications effectuées :

### pays2.tcl par Lucas

# Binds
bind pub - !pays pub:pays
bind msg - pays msg:pays
bind notc - pays notc:pays
bind join - * join:pays

# Données
set pays(be) "Belgique"
set pays(ca) "Canada"
set pays(de) "Allemagne"
set pays(fr) "France"
set pays(sk) "Slovaquie"
set pays(uk) "Royaume-Uni"
set pays(com) "Commercial"
set pays(edu) "Education"
set pays(gov) "Gouvernement"
set pays(mil) "Militaire"
set pays(net) "Réseau"
set pays(org) "Organisation à but non lucratif"

# Procédures
proc pub:pays { nick uhost handle channel arg } {
global pays
if [info exists pays([string tolower $arg])] {
   putserv "PRIVMSG $channel :[string toupper $arg] signifie $pays([string tolower $arg])"
} else {
   putserv "PRIVMSG $channel :[string toupper $arg] n'est pas une extension connue."
}
}

proc msg:pays { nick uhost handle arg } {
global pays
if [info exists pays([string tolower $arg])] {
   putserv "PRIVMSG $nick :[string toupper $arg] signifie $pays([string tolower $arg])"
} else {
   putserv "PRIVMSG $nick :[string toupper $arg] n'est pas une extension connue."
}
}

proc notc:pays { nick uhost handle arg } {
global pays
if [info exists pays([string tolower $arg])] {
   putserv "NOTICE $nick :[string toupper $arg] signifie $pays([string tolower $arg])"
} else {
   putserv "NOTICE $nick :[string toupper $arg] n'est pas une extension connue."
}
}

proc join:pays { nick uhost hand chan } {
putserv "NOTICE $nick :Un script très pratique est disponible sur $chan. Tapez '!Pays <extension>' pour savoir à quel pays correspond une extension."
}

# Fin du script

Il nous reste 2 problèmes à régler :

1. Il faut pouvoir activer le message lors du join à l'aide d'une variable. >LI>Le bot doit pouvoir analyser des demandes comme "!Pays FR BE DE"

1. C'est très simple à faire, il suffit d'utiliser une variable globale.
2. Il faut utiliser une boucle, et assimiler les arguments à une liste :
   for { set index 0 } { $index<[llength $arg] } { incr index } {
   if [info exists pays([string tolower [lindex $arg $index]])] {
      putserv "PRIVMSG $channel :[string toupper [lindex $arg $index]] signifie $pays([string tolower [lindex $arg $index]])"
   } else {
      putserv "PRIVMSG $channel :[string toupper [lindex $arg $index]] n'est pas une extension connue."
   }
   }

Voici donc la version finale du script :

### pays3.tcl par Lucas

# Configuration

# Afficher l'information sur le script lors du join (1 => oui ; 0 => non)
set display_info_pays 0

# Binds
bind pub - !pays pub:pays
bind msg - pays msg:pays
bind notc - pays notc:pays
bind join - * join:pays

# Données
set pays(be) "Belgique"
set pays(ca) "Canada"
set pays(de) "Allemagne"
set pays(fr) "France"
set pays(sk) "Slovaquie"
set pays(uk) "Royaume-Uni"
set pays(com) "Commercial"
set pays(edu) "Education"
set pays(gov) "Gouvernement"
set pays(mil) "Militaire"
set pays(net) "Réseau"
set pays(org) "Organisation à but non lucratif"

# Procédures
proc pub:pays { nick uhost handle channel arg } {
global pays
for { set index 0 } { $index<[llength $arg] } { incr index } {
   if [info exists pays([string tolower [lindex $arg $index]])] {
      putserv "PRIVMSG $channel :[string toupper [lindex $arg $index]] signifie $pays([string tolower [lindex $arg $index]])."
   } else {
      putserv "PRIVMSG $channel :[string toupper [lindex $arg $index]] n'est pas une extension connue."
   }
}
}

proc msg:pays { nick uhost handle arg } {
global pays
for { set index 0 } { $index<[llength $arg] } { incr index } {
   if [info exists pays([string tolower [lindex $arg $index]])] {
      putserv "PRIVMSG $nick :[string toupper [lindex $arg $index]] signifie $pays([string tolower [lindex $arg $index]])."
   } else {
      putserv "PRIVMSG $nick :[string toupper [lindex $arg $index]] n'est pas une extension connue."
   }
}
}

proc notc:pays { nick uhost handle arg } {
global pays
for { set index 0 } { $index<[llength $arg] } { incr index } {
   if [info exists pays([string tolower [lindex $arg $index]])] {
      putserv "NOTICE $nick :[string toupper [lindex $arg $index]] signifie $pays([string tolower [lindex $arg $index]])."
   } else {
      putserv "NOTICE $nick :[string toupper [lindex $arg $index]] n'est pas une extension connue."
   }
}
}

proc join:pays { nick uhost hand chan } {
global display_info_pays
if $display_info_pays {
   putserv "NOTICE $nick :Un script très pratique est disponible sur $chan. Tapez '!Pays ' pour savoir à quel pays correspond une extension."
}
}

# Fin du script

Voilà, notre script est fini. Vous possédez normalement les bases de la programmation en TCL, et vous devriez être capable de faire vos propres scripts. La méthode la plus simple pour progresser est de lire des scripts, comme ceux disponibles dans la rubrique Scripts TCL de ce site, et sur les autres sites sur l'eggdrop.

[ XI. Ressources ]

Tout d'abord, la version finale du script que l'on vient de réaliser, avec la base de données complète d'extensions : pays.tcl
Vous vous demandez sûrement où j'ai trouvé la liste d'extensions/pays. Je ne l'ai pas trouvée sous la forme de script tcl, mais en C. J'ai donc dû la convertir, à l'aide d'un script. Voici l'original : listepays.txt
et le script pour le convertir en TCL : listepays.tcl

Vous trouverez aussi d'autres informations sur le TCL sur ces pages :

• Tcl Commands Manual (TCL v.8.0.5) : http://www.scriptics.com/man/tcl8.0/TclCmd/contents.htm
• TCL Ressouce Center : http://www.scriptics.com/resource/doc/manual/
• Tcl/Tk Manual Pages : http://www.scriptics.com/man/ (fichier tar.gz contenant toute la documentation du TCL disponible)

[ XII. Informations Additionnelles ]

Ces informations se trouvent dans tcl-commands.doc et eggdrop.doc. Mais elles sont assez complexes à manipuler, et une traduction en français n'est à mon avis pas inutile ...

Les Flags

(Original en anglais dans eggdrop.doc)
Les eggdrops n'ont pas de niveaux d'accès comme on peut en trouver dans mIRC. Il n'y a pas de nombres sans signification. A la place, chaque utilisateur a des "flags" qui lui procurent certains privilèges. On peut se représenter les flags comme des badges. Chaque utilisateur peut avoir n'importe quel nombre de badges. Il peut ne pas avoir de badges, ou tous les avoir. Certains badges sont bons, d'autres mauvais.
Les flags standards sont :

• m (master) : quelqu'un qui a accès à quasiment toutes les commandes du bot.
• n (owner) : quelqu'un qui a le contrôle absolu sur le bot. Attention, ce flag ne doit être donné qu'à des personnes de confiance !
• t (botnet) : quelqu'un qui a accès à toutes les commandes permettant de gérer un botnet.
• x (xfer) : quelqu'un qui a accès à la zone de transfert de fichiers du bot (si elle existe) et qui peut envoyer et recevoir des fichiers au/du bot.
• j (janitor) : quelqu'un qui peut faire de la maintenance dans la zone de tranfert de fichiers du bot (si elle existe) - comme un "master" de cette zone.
• c (common) : un utilisateur qui se connecte d'un endroit où d'autres personnes peuvent se connecter à IRC, ce qui rendrait l'information user@host inutile et obsolète.
• p (party) : Quelqu'un qui a accès à la party line
• b (bot) : Marque un utilisateur qui est un bot
• u (unshare) : Cet utilisateur n'est pas envoyé aux autres bots lors du partage de fichier utilisateur.
• h (hilite) : Utilise les caractères gras et en vidéo inverse lors de l'affichage de l'aide ?
• Il y a aussi 26 flags (A-Z en lettres CAPITALES) qui peuvent être utilisés dans des scripts.

Les bots peuvent aussi avoir d'autres flags, qui sont expliqués dans la rubrique botnet de ce site.

Les flags spécifiques à un channel sont : (ils peuvent être appliqués soit globalement, soit spécifiquement à un channel)

• o (op) : Quelqu'un qui peut demander à être mis op (+o) sur le channel.
• d (deop) : Quelqu'un qui ne sera jamais autorisé à être op.
• k (kick) : Quelqu'un qui sera kické à chaque fois qu'il rejoindra le channel.
• f (friend) : Sil le mode revenge est activé, le bot ne sera jamais méchant avec cet utilisateur.
• m (master) : Quelqu'un qui peut ajouter/supprimer/modifier des utilisateurs sur le channel.
• n (owner) : Quelqu'un qui possède un channel
• a (auto-op) : Cette personne est automatiquement mise op quand elle joint le channel.
• v (auto-voice) : Cette personne est automatiquement mise voice quand elle joint le channel.
• q (quiet) : Interdit à cet utilisateur d'être voicé sur un channel en +autovoice.
• Encore une fois, il y a 26 flags (A-Z) pouvant être utilisés dans des scripts.

Masques de caractères

Plusieurs binds vous permettent d'utiliser des masques de caractères dans des arguments. Voici les caractères spéciaux à utiliser :

• ? correspond à un seul caractère (blanc ou caractère)
• * correspond à 0, 1 ou plusieurs caractères (blancs ou caractères)
• % correspond à 0, 1 ou plusieurs caractères qui ne sont pas des espaces (par exemple, correspond à un mot)
• ~ correspond à 1 ou plusieurs caractères blancs (espace, tabulation, etc ...) (Peut être utilisé pour correspondre aux espaces entre deux mots)

[ XIII. Conclusion ]

Vu la longueur de cette initiation au TCL, il est probable qu'il manque des informations, ou que certaines informations soient erronées ou mal expliquées. Si quelque chose vous pose problème, contactez-nous ! Nous serons heureux de pouvoir vous aider.

Source : eggdrop-fr.org