[Script] Petit TCL de gestion

[aliasangelius]

Ok, Maintenant ont va passer à des modifications.
Bien évidament tu va y participer sinon sa ne serait pas drôle que je te fasse tout :p

"Surtout même si tu effectue des erreurs ou que tu n'es pas sur pas grave je suis la pour t'aider hein".

Alors donc pour la partie de ce passage ci :

tcl

putserv "MODE $chan +v $nick"

Tu remplace par le pushmode.
Donc tu prendra exemple sur ce que nous avons vue ensemble "pushmode #accueil +o tonpseudo"
Tu remplace bien evidament "salon" Par la variable adéquate "je te laisse voir ce que tu ferait"
Et ton pseudo par la variable que tu pense que c'est.

Une fois ceci fait montre moi juste la ligne de ce que toi tu ferait.
Après je te dirais si cela et bon ou pas "Si sa ne l'ai pas je te dirais pourquoi etc..'" Je vais vraiment te montrer tout pour sa fait des erreurs ce n'es pas grave, Mais au moins tu va voir que tu peut réussir.

Allez hop montre moi :p

[BaGrift]

Sa donne ca alors ?

code :

tcl

pushmode "MODE $chan +v $nick"

[aliasangelius]

Presque ça :)

En faite pour le pushmode tu n'utilise pas de guillemet : " "
Contrairement à ce qui et puthelp,putserv..

Donc tu retire les guillemet et c'est bon.
Donne ce que sa ferait.

Ensuite tu remplacera cette ligne :

tcl

putquick "KICK $chan $arg Merci de rester calme !"

Par le putkick.
Montre moi comment tu le ferait.

PS : Pour cette partie ci ne pas utilise $arg comme argument pour kick une victime.
Surtout que tu fait un "set nick.." Donc $arg n'a pas lieux d'être présent.

[BaGrift]

Presque ça :)

En faite pour le pushmode tu n'utilise pas de guillemet : " "
Contrairement à ce qui et puthelp,putserv..

Donc tu retire les guillemet et c'est bon.
Donne ce que sa ferait.

Ensuite tu remplacera cette ligne :

tcl

putquick "KICK $chan $arg Merci de rester calme !"

Par le putkick.
Montre moi comment tu le ferait.
PS : Pour cette partie ci ne pas utilise $arg comme argument pour kick une victime.
Surtout que tu fait un "set nick.." Donc $arg n'a pas lieux d'être présent.

Donc si je comprend bien sa donne ça

tcl

pushmode MODE $chan +v $nick

Pour le kick sa donne

tcl

putkick "KICK $chan $nick Reste cool"

[MenzAgitat]

 
Tu peux aussi lire la doc, ça prend 2 secondes.
http://wiki.eggdrop.fr/Putkick
http://wiki.eggdrop.fr/Pushmode
 

[aliasangelius]

@ BaGrift, Oui c'est bon sauf le putkick je le fait comme sa moi :

tcl

putkick $chan $nick :Reste cool !

Le putkick "sert à kick", donc si tu fait :

tcl

putkick "kick..."

La en gros tu retourne le sur, sur le kick lui même.
Sa va pas fonctionner hein :p

Maintenant, Change partout dans ton code ou tu as des mode par pushmode, et ou tu as des kick par putkick.
Et montre le code.

@Menz, Oui mais je vais y venir à tout ceci, Pour le moment je cherche à lui expliquer avec mes mots pour pas qu'il sois perdu.

[CrazyCat]

@Menz, Oui mais je vais y venir à tout ceci, Pour le moment je cherche à lui expliquer avec mes mots pour pas qu'il sois perdu.

Ca fait peur. Ce serait quand même mieux de lui expliquer en français :)

[BaGrift]

@Alias Salut ^^ Tien voila c'est modifié :p

Code :

tcl

####################################
#      Aurel-Tchat Network         #
#   Server irc://irc.aurel-tchat.fr#
# Site-Web http://aurel-tchat.fr   #
# Forum http://forum.aurel-tchat.fr#
####################################
 
################################################################################​#####
#   Attention Si vous toucher le code vous risquer de le faire planter            #
#      Merci de pas toucher si vous avez aucune connaissance dans le domaine du TCL#
################################################################################​##### 
 
#********************#
# Configuration Link #
#********************#
 
set laura(link)    "Laura.*******.fr"
set laura(info)    "Service Moderation"
set laura(host)    "Laura.****.fr"
set laura(ip)       "IP"
set laura(port)    "PORT"
set laura(pass)    "12345678"
set laura(pseudo)   "Laura"
set laura(real)    "Laura Service Moderation"
set laura(ident)    "Laura"
set laura(salon)    "#salon"
set laura(accueil)   "#salon"
set laura(mode)    "+oOSqsw"
 
 
#***********#
# Connexion #
#***********#
 
proc connexion {} {
   global laura
   if {![catch "connect $laura(ip) $laura(port)" laura(idx)]} {
      putdcc $laura(idx) "PASS $laura(pass)"
      putdcc $laura(idx) "SERVER $laura(link) 1 :$laura(info)"
      putdcc $laura(idx) ":$laura(link) NICK $laura(pseudo) 1 [unixtime] $laura(ident) $laura(host) $laura(link) :$laura(real)"
      putdcc $laura(idx) ":$laura(pseudo) MODE $laura(pseudo) $laura(mode)"
      putdcc $laura(idx) ":$laura(pseudo) JOIN $laura(salon)"
      putdcc $laura(idx) ":$laura(pseudo) JOIN $laura(accueil)"
      control $laura(idx) event; utimer 30 verification
   }
}
 
#**************#
# Verification #
#**************#
 
if {![info exists laura(idx)]} { connexion }
 
proc verification {} {
   global laura
   if {[valididx $laura(idx)]} { utimer 30 verification } else { connexion }
}
 
#***********#
# Evenement #
#***********#
 
proc event {idx arg} {
   global laura
   set arg [split $arg]
   if {[lindex $arg 0]=="PING"} { putdcc $idx "PONG [lindex $arg 1]" }
}
 
#**********************#
# Xvoice pour anim      #
#**********************#
 
bind pub n "!xvoice" pub:xvoice
proc pub:xvoice { nick handle uhost chan text } {
pushmode $chan +v $nick
putserv "SAJOIN $nick #Staff"
puthelp "NOTICE $nick Bonne Moderation !"
puthelp "NOTICE $nick Pour savoir mais commandes de modération tape !modere"
putserv "NOTICE $nick Pence Bien a te devoice quand tu anim plus ! => !xdevoice Merci"
}
 
#********************#
# Xdevoice pour anim #
#********************#
 
bind pub n "!xdevoice" pub:xdevoice
proc pub:xdevoice { nick handle uhost chan text } {
pushmode MODE $chan -v $nick
puthelp "NOTICE $nick Merci d'avoir animé $nick"
}
 
#*************#
# Kick Pseudo #
#*************#
 
bind pub n "!kick" pub:kick
proc pub:kick { nick handle uhost chan arg } {
set nick   [lindex $arg 0]
putkick $chan $arg :Merci de rester calme !
   return 1
}
 
#************#
# Ban Pseudo #
#************#
 
bind pub n "!kb" pub:kb
proc pub:kb { nick handle uhost chan arg } {
set nick [lindex $uhost 0]
putquick "MODE $chan +b $arg"
putkick $chan $arg :Reste Cool !
}
 
#*************#
# Appel IRCop #
#*************#
 
bind pub n "!appel" pub:appel
proc pub:appel { nick uhost handle chan arg } {
puthelp "PRIVMSG #Staff $nick Appel un IRCop sur $chan"
putserv "NOTICE $nick Les IRCops on ete appelé"
}
 
#***********#
# Shun Nick #
#***********#
 
set ShunTime   "3m";
bind pub ! "!chut" pub:chut
proc pub:chut { nick uhost handle chan arg } {
set nick [lindex $uhost 0]
putquick "SHUN $arg $::ShunTime Ferme La Un Peux Tu SOul !!! :)"
}
 
#***************#
# Help Commande #
#***************#
 
bind pub X "!modere" pub:help
proc pub:help { nick uhost handle chan arg } {
puthelp "NOTICE $nick Commande De Mderation !"
puthelp "NOTICE $nick La commande !xvoice a utilisé que quand vous moderé sous peine de sanction!"
puthelp "NOTICE $nick La Commande !xdevoice a faire quand vous avez fini de moderé !"
puthelp "NOTICE $nick La commande !kick sert a kické un user du salon !"
puthelp "NOTICE $nick La Commande !kb Sert a kick/ban un user du salon !"
puthelp "NOTICE $nick La commande !appel sert a appelé les IRCop en cas de grosse perturbation sur le salon !"
puthelp "NOTICE $nick La commande !chut sert a coupé la parole a un user pendant 3minute !" 
puthelp "NOTICE $nick Fin Des De Moderation !"
}
 
#*********************#
# Services Moderation #
#*********************#
 
#*************************#
# CONFIG BADWORD       #
#*************************#
 
# prevenir 1 fois avant kick pour les badword? 1/0
set Mod(Warn) 1
 
# si on previent kel est le message a envoyer?
set Mod(WarnMsg) "\002\0030,4Attention! surveillez votre langage! La prochaine fois vous serez expulsé !"
 
# bannir pour badword? 1/0
set Mod(Ban) 1
 
# bannir combien de temps? (en minute)
set Mod(BanTime) 10
 
# kicker pour badword? 1/0
set Mod(Kick) 1
 
# kel raison pour le kick?
set Mod(KickReason) "\002\00312,0Exclu 10 minutes !"
 
#*************************#
# CONFIG REPEAT          #
#*************************#
 
# combien de repetion maxi?
set Mod(RptMax) 3
 
# raisons de kick random pour les repetions
set Mod(Reason) {
   "\002\0036pas besoin de répéter"
   "\002\0030on ne répète pas"
   "\002\0033tu nous dérange en répétant"
}
 
# bannir pour repetition? 1/0
set Mod(BanRep) 1
 
# combien de temps? (en minute)
set Mod(BanRepTime) 10
 
#*************************#
# CONFIG CAPS          #
#*************************#
 
# Max de Caps ?
set Mod(MaxCaps) 10
 
# prevenir la personne en notice ? 1/0
set Mod(CapsWarn) 1
 
# quel message?
set Mod(CapsWarnMsg) "\002\00313Attention! Merci de ne pas ecrire en MAJUSCULE"
 
# kicker les CAPS ? 1/0
set Mod(KCaps) 1
 
# quel raison pour le kick?
set Mod(KCapsReason) "\002\0030,0pas de MAJUSCULE"
 
#*************************#
# CONFIG LONG MOT       #
#*************************#
 
# kicker les longs mots? 1/0
set Mod(MaxMot) 1
 
# taille maxi d'un mot? 1/0
set Mod(MaxMotSize) 20
 
# raison du kick ?
set Mod(MaxMotReason) "\002\00312Flood"
 
 
#************************#
# A ne pas toucher merci #
#************************#
 
proc KReason {} {
   global Mod
   return [lindex $Mod(Reason) [rand [llength $Mod(Reason)]]]
}
 
#on set les listes au demarrage en lisant les fichiers
set BWC ""
foreach c [channels] {
   if {[file exists "Moderator.[string tolower $c].list"]} {
      set f [open Moderator.[string tolower $c].list r]
      set BWL([string tolower $c]) "[string tolower [gets $f]]"
      close $f
      lappend BWC [string tolower $c]
   }
}
 
#proc pour checker si le channel est a surveiller
proc ChkWbBwVar {cha} {
   global BWC
   foreach c $BWC {
      if {$c == "$cha"} {return 1; break}
   }
   return 0
}
 
#check les NOTICE PRIVMSG ACTION SOUND
bind raw - NOTICE PubChkNOT
proc PubChkNOT {from keyword arg} {
   set from [split $from !]
   PubChk [lindex $from 0] [lindex $from 1] * [lindex $arg 0] [lrange $arg 1 end]
}
bind ctcp - ACTION PubChkACTSND
bind ctcp - SOUND PubChkACTSND
proc PubChkACTSND {nick uhost hand dest keyword text} {
   if {[string match &* $dest] || [string match #* $dest]} {
      PubChk $nick $uhost $hand $dest $text
   }
}
bind pubm - * PubChk
proc PubChk {nick userhost handle channel text} {
   global BWN BWL BWC RPT Mod
# anti bad word
   if {[ChkWbBwVar [string tolower $channel]]} {
      set hostban [lindex [split $userhost @] 1]
      set templist [split [string tolower $text] "!&\"'(-_)=~\{\[|`\\^@\]\}\$%µ?,;:/§"]]
      foreach wdt $BWL([string tolower $channel]) {
         if {[lsearch -exact "$templist" $wdt] != -1} {
            if {$Mod(Warn)} {
               if {![info exists BWN([string tolower $userhost])]} {
                  putserv "NOTICE $nick :$Mod(WarnMsg)"
                  set BWN([string tolower $userhost]) [expr [clock seconds] + 1800]
               } else {
                  if {$Mod(Ban)} {newchanban $channel *!*@$hostban Moderator "$Mod(KickReason)" $Mod(BanTime)}
                  if {$Mod(Kick)} {putkick $channel $nick :$Mod(KickReason)}
               }
               return 1
            } else {
               if {$Mod(Ban)} {newchanban $channel *!*@$hostban Moderator "$Mod(KickReason)" $Mod(BanTime)}
               if {$Mod(Kick)} {putkick $channel $nick :$Mod(KickReason)}
               return 1
            }
         }
      }
# anti repetitions
      regsub -all {\\} $text {\\\\} text
      regsub -all {\{} $text {\{} text
      regsub -all {\}} $text {\}} text
      regsub -all {\]} $text {\]} text
      regsub -all {\[} $text {\[} text
      regsub -all {\"} $text {\"} text
      if {[info exists RPT($nick)]} {
         if {[lrange $RPT($nick) 2 end] == "$text"} {
            set cnt [lindex $RPT($nick) 1]; incr cnt
            set RPT($nick) "[lindex $RPT($nick) 0] $cnt [lrange $RPT($nick) 2 end]"
            if {[lindex $RPT($nick) 1] > $Mod(RptMax)} {
               putkick $channel $nick :[KReason]
               if {$Mod(BanRep)} {newchanban $channel *!*@$hostban Moderator "Repeat" 10}
               unset RPT($nick)
            }
         } else {set RPT($nick) "[expr [clock seconds] + 10] 1 $text"}
      } else {set RPT($nick) "[expr [clock seconds] + 10] 1 $text"}
# anti majuscule / longue chaine
      set upper 0
      set space 0
      foreach i [split $text {}] {
         if [string match \[A-Z\] $i] {incr upper}
         if {$i == " "} {incr space}
      }
      if {$upper > $Mod(MaxCaps)} {
          if {$Mod(CapsWarn)} {putserv "NOTICE $nick :$Mod(CapsWarnMsg)"}
         if {$Mod(KCaps)} {putkick $channel $nick :$Mod(KCapsReason)}
      }
      if {$space == 0 && [string length $text] > $Mod(MaxMotSize) && $Mod(MaxMot)} {
         putkick $channel $nick :$Mod(MaxMotReason)
      }
   }
}
proc UnsetRepeat {} {
   global RPT
   foreach nick [array names RPT] {
      if {[lindex $RPT($nick) 0] < [clock seconds]} {unset RPT($nick)}
   }
   utimer 5 UnsetRepeat
}
foreach t [utimers] {
   if {[lindex $t 1] == "UnsetRepeat"} {killutimer [lindex $t 2]}
}
UnsetRepeat
 
#toute les minute on check pour unseter les var des nick qui sont en avertissement
bind time - "* * * * *" UnsetTmpVar
proc UnsetTmpVar {min hour day month year} {
   global BWN RPT
   foreach nt [array names BWN] {
      if {$BWN($nt) < [clock seconds]} {unset BWN($nt)}
   }
}
 
#procs pour ajouter, enlever, lister les mots a bannir
bind dcc o|o addword AddBadWord
proc AddBadWord {hand idx args} {
   global BWL
   set chan [string tolower [lindex [console $idx] 0]]
   if {![validchan $chan]} {putdcc $idx "Console invalide ($chan)"; return 0}
   if {![matchattr [idx2hand $idx] o|o $chan]} {putdcc $idx "Acces refusé pour $chan"; return 0}
   set word [string tolower [lindex $args 0]]
   if {$word == ""} {putdcc $idx ".addword <mot> (ajoute un mot)"; return 0}
   if {![info exists BWL($chan)]} {set BWL($chan) ""}
   if {[lsearch -exact "x $BWL($chan)" "$word"] == -1} {
      lappend BWL($chan) $word
      set f [open Moderator.$chan.list w]
      puts $f "$BWL($chan)"
      close $f
      putdcc $idx "$word ajouté."
      return 1
   } else {putdcc $idx "$word est deja dans la liste! (taper .listword pour voir la liste)"; return 0}
}
bind dcc o|o delword DelBadWord
proc DelBadWord {hand idx args} {
   global BWL
   set chan [string tolower [lindex [console $idx] 0]]
   if {![validchan $chan]} {putdcc $idx "Console invalide ($chan)"; return 0}
   if {![matchattr [idx2hand $idx] o|o $chan]} {putdcc $idx "Acces refusé pour $chan"; return 0}
   if {![info exists BWL($chan)]} {putdcc $idx "Aucun mot pour $chan"; return 0}
   set word [string tolower [lindex $args 0]]
   if {$word == ""} {putdcc $idx ".delword <mot> (efface un mot)"; return 0}
   if {[lsearch -exact "$BWL($chan)" "$word"] != -1} {
      set f [open Moderator.$chan.list r]
      gets $f tmpl
      close $f
      set newlist ""
      foreach t $tmpl {
         if {$t != "$word"} {lappend newlist $t}
      }
      set f [open Moderator.$chan.list w]
      puts $f "$newlist"
      set BWL($chan) $newlist
      close $f
      putdcc $idx "$word éffacé."
      return 1
   } else {putdcc $idx "$word est pas dans la liste! (taper .listword pour voir la liste)"; return 0}
}
bind dcc o|o listword ListBadWord
proc ListBadWord {hand idx args} {
   global BWL
   set chan [string tolower [lindex [console $idx] 0]]
   if {![validchan $chan]} {putdcc $idx "Console invalide ($chan)"; return 0}
   if {![matchattr [idx2hand $idx] o|o $chan]} {putdcc $idx "Acces refusé pour $chan"; return 0}
   if {![info exists BWL($chan)]} {putdcc $idx "Aucun mot pour $chan"; return 0}
   putdcc $idx "Liste des Badwords: $BWL($chan)"
   return 1
}
 
#procs pour ajouter enlever lister les chans a checker
 
bind dcc o|o +modchan AddChan
proc AddChan {hand idx args} {
   global BWC BWL
   set tchan [string tolower [lindex $args 0]]
   if {$tchan == ""} {putdcc $idx ".+modchan <#channel> (ajoute un canal a surveiller)"; return 0}
   if {![validchan $tchan]} {putdcc $idx "Channel invalide ($tchan)"; return 0}
   if {![matchattr [idx2hand $idx] o|o $tchan]} {putdcc $idx "Acces refusé pour $tchan"; return 0}
   if {[lsearch -exact "x $BWC" "$tchan"] == -1} {
 
      set f [open Moderator.$tchan.list w]
      close $f
      set BWL($tchan) ""
 
      set f [open Moderator.chan w]
      puts $f [lappend BWC $tchan]
      close $f
      putdcc $idx "$tchan ajouté."
      return 1
   } else {putdcc $idx "$tchan est deja dans la liste! (taper .modchan pour voir la liste)";return 0}
}
bind dcc o|o -modchan DelChan
proc DelChan {hand idx args} {
   global BWC
   set tchan [string tolower [lindex $args 0]]
   if {$tchan == ""} {putdcc $idx ".-modchan <#channel> (efface un canal surveillé)"; return 0}
   if {![validchan $tchan]} {putdcc $idx "Channel invalide ($tchan)"; return 0}
   if {![matchattr [idx2hand $idx] o|o $tchan]} {putdcc $idx "Acces refusé pour $tchan"; return 0}
   if {[lsearch -exact "x $BWC" "$tchan"] != -1} {
      set f [open Moderator.chan r]
      set tmpl [gets $f]
      close $f
      set newlist ""
      foreach t $tmpl {
         if {$t != "$tchan"} {lappend newlist $t}
      }
      set f [open Moderator.chan w]
      puts $f "$newlist"
      close $f
      set BWC $newlist
      putdcc $idx "$tchan éffacé."
      return 1
   } else {putdcc $idx "$tchan est pas dans la liste! (taper .modchan pour voir la liste)";return 0}
}
bind dcc - modchan ListChan
proc ListChan {hand idx args} {
   global BWC
   putdcc $idx "Liste des canaux: $BWC"
   return 1
}
bind dcc - Moderator Moderator
proc Moderator {hand idx args} {
   global Mod
   putdcc $idx "      Moderator      "
   putdcc $idx ""
   putdcc $idx "ce script comprend un anti badword, un anti"
   putdcc $idx "repetition, un anti caps et un anti long mot."
   putdcc $idx "il agit sur les msgs/notices/actions/sounds"
   putdcc $idx ""
   putdcc $idx "commandes pour les Badword"
   putdcc $idx "addword <mot> 14(ajoute un mot)"
   putdcc $idx "delword <mot> 14(efface un mot)"
   putdcc $idx "listword 14(liste les mots)"
   putdcc $idx ""
   putdcc $idx "commandes pour les canaux"
   putdcc $idx "+modchan 14<#channel> (ajoute un canal a surveiller)"
   putdcc $idx "-modchan 14<#channel> (efface un canal surveillé)"
   putdcc $idx "modchan 14(liste les canaux)"
   putdcc $idx ""
   return 1
}
 
#*********#
#   Fin   #
#*********#

[aliasangelius]

@Crazy lol ! mais non dit pas sa :p

@ BaGrift, Alors je vais te montrer deux choses, et tu va m'expliquer car je comprends pas la..

tcl

bind pub n "!kick" pub:kick
proc pub:kick { nick handle uhost chan arg } {
set nick   [lindex $arg 0]
putkick $chan $arg :Merci de rester calme !
   return 1
}

La pourquoi tu mais $arg ?
Surtout que tu "set nick" la je comprend pas explique moi..
Ensuite return 1 ?
Moi j'aurais plutôt mis un return 0

Seconde :

tcl

bind pub n "!kb" pub:kb
proc pub:kb { nick handle uhost chan arg } {
set nick [lindex $uhost 0]
putquick "MODE $chan +b $arg"
putkick $chan $arg :Reste Cool !
}

Tu peut mettre pushmode aussi pour les bans :)
Et pareil pourquoi $arg ?

[BaGrift]

Salut ^^ :)

Pour te repondre je mais

tcl

$arg

pck ...euh je c pas lol c vrais que pour le !kick cela sert a rien mais en revenche pour le ban a la base je voullais je mètre sur l'host mais ji suis pas arriver lol donc si ta un example je suis preneur

[aliasangelius]

Oui j'ai un très bon exemple, Je l'avais mis dans mon code de Gestion.Bot v2.
Basé sur un code de Menzagitat, Je regarde sa des que je peux et je te file sa !!

Maintenant pour la suite, Ont va regardez comment changer tout ton système de socket etc..
Car ta pas mal de choses manquantes, je vais mettre le mien, avec quelques modif pour qu'il sois adapter au tien "Réseaux".

Après une fois j'aurais changer ceci ont continuera sur tes binds, Optimiser et après "La ou ont va bien galerer", Nous allons rendre toutes c'est commandes gérable que par des sockets.

Ce qui va te permettre d'apprendre comment, et comprendre les sockets.
En gros je t'explique :

Tu aura ont va dire socket principal, qui va gerer le voice/devoice, la secondaire va gerer les kick/ban.. etc.

Le tout utilisable uniquement par : /msg la-socket voice blabla..
Tu aura par exemple cette chose après sur le chan "Socket truc à voice blabla.."
Le tout avec un chanlog.

Et pour finir ensuite une explications avec des liens etc pour compléter les explications binds etc..
Si cela te va ?

[BaGrift]

Salut,

Oui cela me va sa va me permettre a mieux comprend pck j'avoue se suis novice dans le domaine tcl et je suis perdu lol

[aliasangelius]

Salut, L'envie ma pris..
Alors j'ai refait ton code plus ou moins, J'ai pas tout fait.. Car tu aura des exemples et tu devrais y arrivée.
Alors je n'es pas fait les commandes par socket "pas encore manque de temps désoler.."
Ensuite je t'es refait certaines erreurs, Dont pour le système de ban "a tester comme tout le reste du code".

Je te transmet le code entier, basé sur le mien, mais modifié pour ton réseau, Par la suite nous feront certains changement je pense.
Pour ce qui et de la modération, jette sa à la poubelle.. Je te passerais ma version bêta à moi par mp, je ne l'ai jamais fini tu la testera comme sa.

Voici donc le code refait :

tcl

#*************************************************#
# Système de sockets pour le réseaux Aurel-Tchat. #
# Fait par alias_angelius avec BaGrift.           #
#*************************************************#
 
namespace eval ::socks {
   variable aurore
 
#********************#
# Service.Socket 1.0 #
#********************#
 
#**************************#
# Information link reseau. #
#**************************#
 
set aurore(serv) "Aurore.****.fr"
set aurore(ip) "ip"
set aurore(port) "port"
set aurore(pwdlink) "pass"
set aurore(info) "Aurore Services"
 
#****************************#
# Configuration des sockets. #
#****************************#
 
set aurore(nick) "Laura"
set aurore(identd) "Laura"
set aurore(host) "Services.****.fr"
set aurore(nom) "Laura Service Moderation"
 
#***************************#
# Salon de log des sockets. #
#***************************#
 
set aurore(log) "#Services"
set aurore(quit01) "Redemarage Laura-Service."
set aurore(quit02) "Fermeture Laura-Service."
 
#****************************************#
# Lancement de la procédure des sockets. #
#****************************************#
 
proc checkconnect {} {
   if {![info exists aurore(idx)]} { utimer 30 [namespace current]::checkconnect } else { xconnect:serv }
}
 
proc xconnect:serv {} {
   variable aurore
   if [catch {set aurore(idx) [connect $aurore(ip) $aurore(port)]} err] {
      putlog "Connection error :$err"
      return
   }
   putdcc $aurore(idx) "PASS $aurore(pwdlink)"
   putdcc $aurore(idx) "SERVER $aurore(serv) 1 [unixtime] :$aurore(info)"
   putdcc $aurore(idx) ":$aurore(serv) NICK $aurore(nick) '' '' $aurore(identd) $aurore(host) $aurore(serv) '' :$aurore(nom)"
   putdcc $aurore(idx) ":$aurore(nick) MODE $aurore(nick) +oOSqsw"
   putdcc $aurore(idx) ":$aurore(nick) JOIN $aurore(log)"
   putdcc $aurore(idx) ":$aurore(nick) MODE $aurore(log) +ntsv $aurore(nick)"
   control $aurore(idx) [namespace current]::controling_server
   utimer 10 [namespace current]::verify
}
 
#***********************************#
# Verify si le serveur est Connecté #
#***********************************#
 
proc verify {} {
   variable aurore
   if [valididx [set [namespace current]::aurore(idx)]] {
      utimer 30 [namespace current]::verify
   } else {
      xconnect:serv
   }
}
 
proc controling_server {idx arg} {
   variable aurore
   set arg1 [lindex [split $arg " "] 0]
   set arg2 [lindex [split $arg " "] 1]
   set arg3 [lindex [split $arg " "] 2]
   set arg4 [lindex [split $arg " "] 3]
   set arg5 [lindex [split $arg " "] 4]
   set arg6 [lindex [split $arg " "] 5]
   set arg7 [lindex [split $arg " "] 6]
   set arg8 [lindex [split $arg " "] 7]
   set arg10 [string trim [lrange [split $arg " "] 3 end] :]
   if {$arg2=="PING"} {
      putdcc $aurore(idx) ":$aurore(serv) PONG $aurore(ip) :$aurore(serv)"
    }   
}
 
#**********************#
# Restart des sockets. #
#**********************#
 
bind evnt - prerestart [namespace current]::eva:restart
proc eva:restart {args} {
   variable aurore
   putdcc $aurore(idx) ":$aurore(serv) SQUIT $aurore(serv) :Restart Sockets."
   catch {close $aurore(idx)}
}
 
#********************#
# Rehash du Service. #
#********************#
 
bind dcc n xrehash [namespace current]::eggy:xrehash
proc eggy:xrehash {nick idx arg} {
   variable aurore
   putdcc $idx "\002Rehash de Aurore-Service et des fichiers\002"
   utimer 4 rehash
}
 
#*********************#
# Restart du Service. #
#*********************#
 
bind dcc n xrestart [namespace current]::eggy:xrestart
proc eggy:xrestart {nick idx arg} {
   variable aurore
   putdcc $idx "\002Redémarrage de Aurore-service\002"
   if [valididx [set [namespace current]::aurore(idx)]] {
      putdcc $aurore(idx) ":$aurore(nick) QUIT :$aurore(quit01)"
      putdcc $aurore(idx) ":$aurore(serv) SQUIT :$aurore(serv)"
      catch {close $aurore(idx)}
      foreach kill [utimers] {
          if {[lindex $kill 1]=="[namespace current]::verify"} { killutimer [lindex $kill 2] }
      }
    }
    xconnect:serv
}
 
#*****************#
# Die du Service. #
#*****************#
 
bind dcc n xdie [namespace current]::eggy:xdie
proc eggy:xdie {nick idx arg} {
    putdcc $idx "\002Arrêt de Aurore-Service\002"
    if [valididx [set [namespace current]::aurore(idx)]] {
       putdcc $aurore(idx) ":$aurore(nick) QUIT : $aurore(quit02)"
       putdcc $aurore(idx) ":$aurore(serv) SQUIT :$aurore(quit02)"
       catch {close $aurore(idx)}
       foreach kill [utimers] {
          if {[lindex $kill 1]=="[namespace current]::verify"} { killutimer [lindex $kill 2] }
       }
   }
}
 
#********************#
# Xvoice Pour Anims. #
#********************#
 
bind pub n "!xdevoice" [namespace current]::xdevoice
proc xdevoice { nick handle uhost chan text } {
    pushmode $chan -v $nick
    puthelp "NOTICE $nick :Merci d'avoir animé $nick"
}
 
#**************#
# Kick Pseudo. #
#**************#
 
bind pub n "!kick" [namespace current]::kick
proc kick { nick hand host chan arg } {
    set nick [lindex $arg 0]
    putkick $chan $nick "Merci de rester calme !"
    return 0
}
 
#*************#
# Ban Pseudo. #
#*************#
 
bind pub n "!kb" pub:kb
proc pub:kb { nick hand host chan arg } {
    # Ici j'ai changer ton set, pour split sur un host.
    set nik [lindex [split $nick !] 0]
    # Ici je re split sur l'host.
    set host [lindex [split $nick !] 1]
    # Ici je re set arg, au cas ou plus tard faudra faire une modification.
    set arg [lindex [split $args] 1 end]
    # Maintenant ont ban sur le nick et le host.
    pushmode $chan +b $nik!$host
    putkick $chan $nick "Reste Cool !"
}
 
#**************#
# Appel Ircop. #
#**************#
 
bind pub n "!appel" [namespace current]::appel
proc appel { nick uhost handle chan arg } {
    variable aurore
    puthelp "PRIVMSG $aurore(log) $nick Appel un IRCop sur $chan"
    putserv "NOTICE $nick Les IRCops on ete appelé"
}
 
#****************#
# Help Commande. #
#****************#
 
bind pub X "!modere" [namespace current]::help
proc help { nick uhost handle chan arg } {
    set commande [lindex $arg 1]
    set commande [stripcodes abcu [lindex $arg 0]]
    if {$commande == ""} {
        puthelp "privmsg $nick :\00314Commande Help du Robot \002\0034$::botnick\002\0034"
        puthelp "privmsg $nick :\017"
        puthelp "privmsg $nick :\0034!xvoice\0034 \0031a utilisé que quand vous moderé sous peine de sanction!\0031"
        puthelp "privmsg $nick :\0034!xdevoice\0034 \0031a faire quand vous avez fini de moderé !\0031"
        puthelp "privmsg $nick :\0034!kick\0034 \0031sert a kické un user du salon !\0031"
        puthelp "privmsg $nick :\0034!kb\0034 \0031Sert a kick/ban un user du salon !\0031"
        puthelp "privmsg $nick :\0034!appel\0034 \0031sert a appelé les IRCop en cas de grosse perturbation sur le salon !\0031"
        puthelp "privmsg $nick :\0034!chut\0034 \0031sert a coupé la parole a un user pendant 3minute !\0031"
        # La commande !chute, je ne l'ai pas mise je te laisse le faire en regardant comment j'ai fait partout pour tes binds. Faut tu bosse un peut quand même !
        puthelp "privmsg $nick :\00314Fin Help du Robot \002\0034$::botnick\002\0034"
    }
}
 
#************************************************************************************************************#
# Tu as le principal, il te reste à ajouter/modifier ce que toi tu semble vouloir,                           #
# J'ai juste mis les commande par ton eggdrop, je n'es pas encore fait par socket.                           #
# Les commandes disponibles par sockets je le ferait une autre fois lorsquej'aurais plus de temps pour cela. #
# Je reste quand même à disposition au cas ou.                                                               #
#************************************************************************************************************#
 
#****************************#
# Fin du Service Sockets 1.0 #
#****************************#
# connection 
[namespace current]::xconnect:serv
}
 
putlog "\0031Service Sockets 1.0 \0034Chargé."

[BaGrift]

Salut; :p

Cela me plait bcp le taff que tu fais jamais j’aurai réussi a faire se code lol merci a toi c gentil :)

[aliasangelius]

De rien :p
Juste il manquera quelques trucs par la suite, mais ont va le rendre de mieux en mieux pour tu comprenne bien !

Test le prend ton temps hein et des que je pourrais je passerais à la secondes étapes ;)