wilkowe skrypty dla Eggdropa

Wszystko co chcielibyście wiedzieć o kanale, poznać historię jego powstawania, dowiedzieć się kto nim administruje i jaki jest regulamin, zobaczyć osiągnięcia naszych najlepszych graczy oraz sprawdzić globalny ranking Q-punktów, bądź poczytać kompendium wiedzy o quizach IRC-owych.

Polecenia: IRC, quizbot, statbot, funbot

wilkowe skrypty dla Eggdropa

Postprzez wilk » 10 lutego 2016, 18:40

Może komuś się przydadzą niektóre moje skrypty dla Eggdropa, które napisałem m.in. dla naszego #:

topicresync.tcl (v1.13) - ustawia ponownie topic po 15 minutach po splicie. Serwery nie synchronizują topiców i jeśli split był spowodowany np. wyłączeniem serwera, to osoby, które wejdą później z niego na kanał nie będą w ogóle widziały topica. Dodatkowo skrypt zapamiętuje zmiany topica dokonane przez operatorów i w razie gdyby był pusty, to przywraca ostatni zapamiętany stan. Można też ustawić dla każdego kanału topic domyślny, który będzie ustawiany w ostateczności (brak topica po netsplicie i żaden op nie zmieniał go wcześniej). Należy ustawić (przez partyline) na kanałach, na których ma on działać flagę "topicresync" (.chanset #kanal +topicresync). Skrypt dodaje polecenie ".topicresync" dostępne przez partyline.

Kod: Zaznacz cały
# Name      Topic Resync & Recovery after a netsplit
# Author   wilk wilkowy
# Version   1.13 (2015..2017-07-14)
# License   GNU GPL v2 or any later version

# Todo: move vars to .chanset

# Resync delay in minutes (0 - instant).
set topres_delay 15

# Protect against floods (inertia), in seconds (0 - off).
set topres_protect 30

# Resync topic everywhere (unless set by @ before timer runs out) [1] or only on channels where someone netsplitted [0].
set topres_everywhere 1

# Default channel topics.
#set topres_default(#channel) "Hello!"

# On/off .chanset flag.
setudef flag topicresync

bind rejn - * topres:check
bind topc o|o * topres:change
bind dcc n|n topicresync topres:dcc

if {![info exists topres_flood]} { set topres_flood 0 }

proc topres:dcc {hand idx text} {
   if {$text eq "now"} {
      topres:resync
      return 1
   } elseif {$text eq "info"} {
      topres:info $idx
   } else {
      putdcc $idx "Usage: .topicresync <info/now>"
   }
   return
}

proc topres:cleantxt {text} {
   return [string map {"\002" "B" "\003" "C" "\017" "P" "\026" "R" "\037" "U" "\035" "I"} $text]
}

proc topres:check {nick uhost hand chan} {
   global topres_timer topres_delay topres_flood topres_protect topres_resync
   set topres_resync($chan) 1
   if {$topres_protect > 0} {
      if {$topres_flood} { return }
      set topres_flood 1
      utimer $topres_protect [list set topres_flood 0]
   }
   if {[info exists topres_timer] && [lsearch -glob [timers] "*$topres_timer"] != -1} {
      killtimer $topres_timer
   }
   if {$topres_delay > 0} {
      set topres_timer [timer $topres_delay topres:resync]
   } else {
      topres:resync
   }
   return
}

proc topres:change {nick uhost hand chan topic} {
   global topres_topic topres_resync
   set topres_topic($chan) $topic
   set topres_resync($chan) 0
   return
}

proc topres:resync {} {
   global topres_topic topres_default topres_resync topres_everywhere topres_timer
   if {[info exists topres_timer]} {
      unset topres_timer
   }
   foreach chan [channels] {
      if {![channel get $chan topicresync] || ![botisop $chan]} { continue }
      if {[info exists topres_resync($chan)]} {
         set resync $topres_resync($chan)
      } else {
         set resync $topres_everywhere
      }
      set topres_resync($chan) $topres_everywhere
      if {!$resync} { continue }
      set chtopic [topic $chan]
      if {$chtopic ne ""} {
         set topic [topres:cleantxt $chtopic]
         set length [format "%03d" [string length $topic]]
         putlog "Topic resync ($chan) \[$length]: $topic"
         putserv "TOPIC $chan :$chtopic"
         set topres_topic($chan) $chtopic
      } elseif {[info exists topres_topic($chan)] && $topres_topic($chan) ne ""} {
         set topic [topres:cleantxt $topres_topic($chan)]
         set length [format "%03d" [string length $topic]]
         putlog "Topic recovery ($chan) \[$length]: $topic"
         putserv "TOPIC $chan :$topres_topic($chan)"
      } elseif {[info exists topres_default($chan)] && $topres_default($chan) ne ""} {
         set topic [topres:cleantxt $topres_default($chan)]
         set length [format "%03d" [string length $topic]]
         putlog "Topic default ($chan) \[$length]: $topic"
         putserv "TOPIC $chan :$topres_default($chan)"
         set topres_topic($chan) $topres_default($chan)
      }
   }
}

proc topres:info {idx} {
   global topres_topic topres_default
   foreach chan [channels] {
      if {![channel get $chan topicresync]} {
         putdcc $idx "* Channel $chan: (resync disabled)"
      } elseif {[channel get $chan inactive]} {
         putdcc $idx "* Channel $chan: (inactive)"
      } elseif {![botonchan $chan]} {
         putdcc $idx "* Channel $chan: (not on channel)"
      } else {
         set status ""
         if {![botisop $chan]} {
            set status " (need ops)"
         }
         putdcc $idx "* Channel $chan:$status"
         set topic [topres:cleantxt [topic $chan]]
         set length [format "%03d" [string length $topic]]
         putdcc $idx "| Topic (current) \[$length] : $topic"
         if {[info exists topres_topic($chan)]} {
            set topic [topres:cleantxt $topres_topic($chan)]
            set length [format "%03d" [string length $topic]]
            putdcc $idx "| Topic (backup) \[$length]  : $topic"
         }
         if {[info exists topres_default($chan)]} {
            set topic [topres:cleantxt $topres_default($chan)]
            set length [format "%03d" [string length $topic]]
            putdcc $idx "| Topic (default) \[$length] : $topic"
         }
      }
   }
}

putlog "Topic Resync v1.13 by wilk"

topicupdate.tcl (v1.14) - ten skrypt jest bardziej dla nas tylko, ale nadaje się na kanały quizowe — automatyzuje aktualizowanie w topicu informacji o nadchodzącym quizie (często o tym zapominaliśmy). Zmienia (zielony) ciąg "\0033Nastepny quiz: nazwa_dnia (dzień.miesiąc)" na: w przeddzień quizu: (czerwony) "\0034Nastepny quiz: jutro", a potem: "jutro" na "dzis". Zmiana następuje o północy, ale oczywiście można to zmienić. Należy ustawić (przez partyline) na kanałach, na których ma on działać flagę "topicupdate" (.chanset #kanal +topicupdate). Skrypt dodaje polecenie ".topicupdate" dostępne przez partyline.

Kod: Zaznacz cały
# Name      Topic Update: data->jutro->dzis
# Author   wilk wilkowy
# Version   1.14 (2015..2017-07-07)
# License   GNU GPL v2 or any later version

# On/off .chanset flag.
setudef flag topicupdate

bind time - "00 00 *" topupd:update
bind dcc n|n topicupdate topupd:dcc

proc topupd:dcc {hand idx text} {
   if {$text eq "now"} {
      topupd:update logfile
      return 1
   } else {
      putdcc $idx "Usage: .topicupdate <now>"
   }
   return
}

proc topupd:update {minute hour day month year} {
   set now_day [strftime %-d]
   set now_month [strftime %-m]
   foreach chan [channels] {
      if {![channel get $chan topicupdate] || ![botisop $chan]} { continue }
      set topic [topic $chan]
      if {$topic eq ""} { continue }
      set oldtopic $topic
      set update 0
      if {[string match -nocase "*jutro*" $topic]} {
         set topic [string map -nocase {"JUTRO" "DZIS"} $topic]
         regsub -all -nocase -- "\0030?3((?:Nast|Next|Quiz)\[^:\]*?: DZIS )" $topic "\0034\\1" topic
         incr update
      }
      set matches [regexp -all -inline -nocase -- {(?:(?:\mwe? )?(?:poniedzialek|po?n\.|wtorek|wto?\.|srod[ae]|sro?\.|czwartek|czw\.|piatek|piat?\.|pt\.|sobot[ae]|sob\.|niedziel[ae]|nie\.|niedz\.) )?\(([0-3]?[0-9])[./]([01]?[0-9])\)} $topic]
      foreach {match event_day event_month} $matches {
         set event_day [scan $event_day %d]
         set event_month [scan $event_month %d]
         set prev_day [expr {$event_day - 1}]
         set prev_month $event_month
         set prev_year [strftime %Y]
         if {$prev_day == 0} {
            incr prev_month -1
            if {$prev_month == 0} {
               set prev_month 12
               incr prev_year -1
            }
            if {$prev_month == 2} {
               set prev_day 28
               if {([expr {$prev_year % 4}] == 0 && [expr {$prev_year % 100}] != 0) || [expr {$prev_year % 400}] == 0} {
                  incr prev_day 1
               }
            } elseif {$prev_month in [list 1 3 5 7 8 10 12]} {
               set prev_day 31
            } else {
               set prev_day 30
            }
         }
         set soon ""
         if {$now_day == $prev_day && $now_month == $prev_month} {
            set soon "JUTRO"
         } elseif {$now_day == $event_day && $now_month == $event_month} {
            set soon "DZIS"
         }
         if {$soon ne ""} {
            set topic [string map -nocase [list $match $soon] $topic]
            regsub -nocase -- "\0030?3((?:Nast|Next|Quiz)\[^:\]*?: )" $topic "\0034\\1" topic
            incr update
         }
      }
      if {$update} {
         putlog "Topic update ($chan) from: $oldtopic"
         putlog "Topic update ($chan) to  : $topic"
         putserv "TOPIC $chan :$topic"
      }
   }
   return
}

putlog "Topic Update v1.14 by wilk"

autolimit.tcl (v1.10) - automatycznie pilmuje limitu kanałowego (ochrona przed mass-joinem). Sposób działania skryptu bazuje na rozwiązaniu zaimplementowanym w bocie IRC-owym Psotnic (przy którego powstawaniu nota bene też miałem swój wkład). W przeciwieństwie do klasycznych skryptów, które aktualizują na sztywno limit co kilka minut — tutaj wyzwalaczem timerów jest wejście/zniknięcie z kanału. Dodatkowo są osobne timery dla zwiększania limitu i zmniejszania (szybciej obniża) oraz osobne dla zmian wprowadzonych przez ownera kanału czy operatorów. Skrypt obsługuje wiele kanałów i na tych, na których ma działać należy ustawić (przez partyline) flagę "autolimit" (.chanset #kanal +autolimit). Ponadto dostępna jest funkcja włączana flagą kanałową "lockdown", która ustawia na kanale flagę "i" w chwili wejścia maksymalnej liczby osób dopuszczonej bieżącym limitem - pozwala ona ochronić kanał przed atakami klonów robiącymi wielokrotne join/part. Skrypt dodaje też polecenie ".autolimit" dostępne z poziomu partyline.

Kod: Zaznacz cały
# Name      Auto Limit Updater (based on Psotnic limiter)
# Author   wilk wilkowy
# Version   1.10 (2016..2017-07-14)
# License   GNU GPL v2 or any later version

# Todo: move vars to .chanset
# Todo: add dcc cmds w/o enforcing

# Limit update latency in seconds - new user (0 - instant, min:max notation allowed).
set alimit_delay_up 120

# Limit update latency in seconds - gone user (0 - instant, min:max notation allowed).
set alimit_delay_down 30

# Limit update latency in seconds - bot got opped (0 - instant, -1 - ignore, min:max notation allowed).
set alimit_delay_gotop 5

# Limit update latency in seconds - server mode change (netsplit) (0 - instant, -1 - ignore, min:max notation allowed).
set alimit_delay_server 5

# Limit update latency in seconds - owner mode change (0 - instant, -1 - ignore, min:max notation allowed).
set alimit_delay_owner -1

# Limit update latency in seconds - bot mode change (0 - instant, -1 - ignore, min:max notation allowed).
set alimit_delay_bot 120

# Limit update latency in seconds - @ mode change (0 - instant, -1 - ignore, min:max notation allowed).
set alimit_delay_op 0

# Limit update latency in seconds - someone else mode change (0 - instant, -1 - ignore, min:max notation allowed).
set alimit_delay_unknown 0

# Keep this amount of free limit space for users.
set alimit_offset 5

# Limit tolerance to reduce amount of unnecessary updates (<0 - percent of offset, >0 - static, 0 - off).
set alimit_tolerance -50

# Protect against floods (inertia), in seconds (0 - off).
set alimit_protect 15

# Lockdown duration in seconds (0 - off). Lockdown closes the channel (+i) to prevent join/part floods with clones
set alimit_lockdown_time 30

# On/off .chanset flags.
setudef flag autolimit
setudef flag lockdown

bind join - * alimit:join
#bind rejn - * alimit:netjoin
bind part - * alimit:part
bind sign - * alimit:quit
bind kick - * alimit:kick
bind mode - *+l* alimit:mode
bind mode - *-l* alimit:mode
bind mode - *+o* alimit:mode
bind dcc n|n autolimit alimit:dcc

proc alimit:dcc {hand idx text} {
   if {$text eq "info"} {
      alimit:info $idx
   } elseif {$text eq "all"} {
      foreach chan [channels] {
         alimit:update $chan 1
      }
      return 1
   } elseif {[validchan $text]} {
      alimit:update $text 1
      return 1
   } else {
      putdcc $idx "Usage: .autolimit <info/all/#>"
   }
   return
}

proc alimit:getdelay {value} {
   set time [split $value ":"]
   if {[llength $time] > 1} {
      set min [lindex $time 0]
      set max [lindex $time 1]
      if {$min > $max} {
         foreach {min max} [list $max $min] {break}
      }
      return [expr {[rand [expr {$max + 1 - $min}]] + $min}]
   } else {
      return $value
   }
}

proc alimit:getlimit {chan} {
   set modes [split [getchanmode $chan]]
   if {[string match *l* [lindex $modes 0]]} {
      return [lindex $modes end]
   } else {
      return ""
   }
}

proc alimit:islocked {chan} {
   return [string match *i* [lindex [split [getchanmode $chan]] 0]]
}

proc alimit:join {nick uhost hand chan} {
   global alimit_delay_up alimit_lockdown_time alimit_lockdown
   if {$alimit_lockdown_time > 0 && [channel get $chan lockdown] && [botisop $chan]} {
      set limit [alimit:getlimit $chan]
      if {$limit ne "" && [llength [chanlist $chan]] == $limit && ![alimit:islocked $chan]} {
         if {![info exists alimit_lockdown($chan)] || $alimit_lockdown($chan) == 0} {
            set alimit_lockdown($chan) 1
            pushmode $chan +i
            putlog "Channel full ($chan) - lockdown!"
            utimer $alimit_lockdown_time [list alimit:unlock $chan]
         }
      }
   }
   alimit:change $chan $alimit_delay_up
   return
}

proc alimit:unlock {chan} {
   global alimit_lockdown
   set alimit_lockdown($chan) 0
   pushmode $chan -i
   putlog "Lockdown lifted ($chan)"
}

proc alimit:part {nick uhost hand chan {msg ""}} {
   global alimit_delay_down
   alimit:change $chan $alimit_delay_down
   return
}

proc alimit:quit {nick uhost hand chan why} {
   global alimit_delay_down
   alimit:change $chan $alimit_delay_down
   return
}

proc alimit:kick {nick uhost hand chan whom why} {
   global alimit_delay_down
   alimit:change $chan $alimit_delay_down
   return
}

proc alimit:mode {nick uhost hand chan mode whom} {
   global alimit_delay_server alimit_delay_gotop alimit_delay_owner alimit_delay_bot alimit_delay_op alimit_delay_unknown
   if {[isbotnick $nick] || ![botisop $chan]} { return }
   if {$mode eq "+o" && [isbotnick $whom]} {
      if {$alimit_delay_gotop < 0} { return }
      alimit:change $chan $alimit_delay_gotop 1
   } elseif {($mode eq "-l" || $mode eq "+l")} {
      set enforce 0
      if {$nick eq "" && $hand eq "*"} {
         if {$alimit_delay_server < 0} { return }
         set delay $alimit_delay_server
         if {$mode eq "-l"} { set enforce 1 }
      } elseif {$hand ne "" && $hand ne "*" && [matchattr $hand b|- $chan]} {
         if {$alimit_delay_bot < 0} { return }
         set delay $alimit_delay_bot
      } elseif {$hand ne "" && $hand ne "*" && [matchattr $hand n|n $chan]} {
         if {$alimit_delay_owner < 0} { return }
         set delay $alimit_delay_owner
      } elseif {$hand ne "" && $hand ne "*" && [matchattr $hand o|o $chan]} {
         if {$alimit_delay_op < 0} { return }
         set delay $alimit_delay_op
         if {$mode eq "-l"} { set enforce 1 }
      } else {
         if {$alimit_delay_unknown < 0} { return }
         set delay $alimit_delay_unknown
         if {$mode eq "-l"} { set enforce 1 }
      }
      alimit:change $chan $delay 1 $enforce
   }
   return
}

proc alimit:change {chan delay {nocheck 0} {enforce 0}} {
   global alimit_timer alimit_flood alimit_protect
   if {!$nocheck && $alimit_protect > 0} {
      if {[info exists alimit_flood($chan)] && $alimit_flood($chan)} { return }
      set alimit_flood($chan) 1
      utimer $alimit_protect [list set alimit_flood($chan) 0]
   }
   if {[info exists alimit_timer($chan)] && [lsearch -glob [utimers] "*$alimit_timer($chan)"] != -1} {
      killutimer $alimit_timer($chan)
   }
   set _delay [alimit:getdelay $delay]
   if {$_delay > 0} {
      set alimit_timer($chan) [utimer $_delay [list alimit:update $chan $enforce]]
   } else {
      alimit:update $chan $enforce
   }
}

proc alimit:update {chan {enforce 0}} {
   global alimit_offset alimit_tolerance alimit_limit alimit_timer
   if {[info exists alimit_timer($chan)]} {
      unset alimit_timer($chan)
   }
   if {![channel get $chan autolimit] || ![botisop $chan]} { return }
   set users [llength [chanlist $chan]]
   set limit [alimit:getlimit $chan]
   set new_limit [expr {$users + $alimit_offset}]
   if {$limit ne "" && $new_limit == $limit && !$enforce} { return }
   if {$alimit_tolerance >= 0} {
      set tolerance $alimit_tolerance
   } else {
      set tolerance [expr {int($alimit_offset * $alimit_tolerance / -100.0)}]
   }
   if {$enforce || $limit eq "" || $limit < [expr {$users + $alimit_offset - $tolerance}] || $limit > [expr {$users + $alimit_offset + $tolerance}]} {
      if {$limit eq ""} {
         set limit "none"
      }
      putlog "Limit change ($chan/$users): $limit -> $new_limit"
      pushmode $chan +l $new_limit
      set alimit_limit($chan) $new_limit
      #flushmode $chan
   }
}

proc alimit:info {idx} {
   global alimit_tolerance alimit_offset alimit_timer
   foreach chan [channels] {
      if {![channel get $chan autolimit]} {
         putdcc $idx "* Channel $chan: (autolimit disabled)"
      } elseif {[channel get $chan inactive]} {
         putdcc $idx "* Channel $chan: (inactive)"
      } elseif {![botonchan $chan]} {
         putdcc $idx "* Channel $chan: (not on channel)"
      } else {
         set status ""
         if {![botisop $chan]} {
            set status " (need ops)"
         }
         putdcc $idx "* Channel $chan:$status"
         if {$alimit_tolerance >= 0} {
            set tolerance $alimit_tolerance
         } else {
            set tolerance [expr {int($alimit_offset * $alimit_tolerance / -100.0)}]
         }
         set limit [alimit:getlimit $chan]
         set users [llength [chanlist $chan]]
         set range "NOONE"
         if {$limit eq ""} {
            set range "ANYONE"
         } elseif {$limit > 0} {
            set min [expr {$limit - $alimit_offset - $tolerance}]
            set max [expr {$limit - $alimit_offset + $tolerance}]
            set range "$min..$max"
         }
         putdcc $idx "| Users : $users \[current limit allows: $range]"
         set exp [expr {$users + $alimit_offset}]
         set min [expr {$exp - $tolerance}]
         set max [expr {$exp + $tolerance}]
         set status "ok"
         if {$limit eq "" || $limit < $min || $limit > $max} { set status "update required" }
         if {[info exists alimit_timer($chan)]} {
            set timers [utimers]
            set timer [lsearch -glob $timers "*$alimit_timer($chan)"]
            if {$timer != -1} {
               append status ", update in [lindex $timers $timer 0]s"
               if {[lindex $timers $timer 1 2] == 1} { append status ", forced" }
            }
         }
         if {$limit eq ""} {
            set limit "none"
         }
         putdcc $idx "| Limit : $limit \[expected: $exp, allowed: $min..$max] ($status)"
      }
   }
}

putlog "Auto Limit v1.10 by wilk"

pcc.tcl (v1.8) - zestaw poleceń kanałowych do obsługi bota czy pozwalających wybranym użytkownikom np. na dawanie plusików, bez posiadania opa. Na kanałach, na których ma działać należy ustawić flagę "chancmds" (.chanset #kanal +chancmds).

Kod: Zaznacz cały
# Name      Public Channel Commands
# Author   wilk wilkowy
# Version   1.8 (2007..2017-01-09)
# License   GNU GPL v2 or any later version

set pcc_char "!"

setudef flag chancmds

bind pub m|m ${pcc_char}o pcc:op
bind pub m|m ${pcc_char}op pcc:op
bind pub m|m ${pcc_char}do pcc:deop
bind pub m|m ${pcc_char}deop pcc:deop

bind pub v|v ${pcc_char}v pcc:voice
bind pub v|v ${pcc_char}voice pcc:voice
bind pub v|v ${pcc_char}dv pcc:devoice
bind pub v|v ${pcc_char}devoice pcc:devoice

bind pub o|o ${pcc_char}k pcc:kick
bind pub o|o ${pcc_char}kick pcc:kick
bind pub m|m ${pcc_char}b pcc:ban
bind pub m|m ${pcc_char}ban pcc:ban
bind pub m|m ${pcc_char}kb pcc:kban
bind pub m|m ${pcc_char}kickban pcc:kban
bind pub m|m ${pcc_char}ub pcc:unban
bind pub m|m ${pcc_char}unban pcc:unban

bind pub o|o ${pcc_char}t pcc:topic
bind pub o|o ${pcc_char}topic pcc:topic
bind pub n|n ${pcc_char}m pcc:mode
bind pub n|n ${pcc_char}mode pcc:mode
bind pub m|m ${pcc_char}s pcc:shutup
bind pub m|m ${pcc_char}silence pcc:shutup
bind pub m|m ${pcc_char}shutup pcc:shutup
bind pub m|m ${pcc_char}l pcc:ulimit
bind pub m|m ${pcc_char}limit pcc:ulimit
bind pub m|m ${pcc_char}ulimit pcc:ulimit
bind pub m|m ${pcc_char}unlimit pcc:ulimit
bind pub n|n ${pcc_char}lock pcc:lock
bind pub n|n ${pcc_char}unlock pcc:unlock

bind pub n|- ${pcc_char}au pcc:adduser
bind pub n|- ${pcc_char}+user pcc:adduser
bind pub n|- ${pcc_char}adduser pcc:adduser
bind pub n|- ${pcc_char}du pcc:deluser
bind pub n|- ${pcc_char}-user pcc:deluser
bind pub n|- ${pcc_char}deluser pcc:deluser
bind pub n|- ${pcc_char}ah pcc:addhost
bind pub n|- ${pcc_char}+host pcc:addhost
bind pub n|- ${pcc_char}addhost pcc:addhost

bind pub n|- ${pcc_char}rehash pcc:rehash
bind pub n|- ${pcc_char}restart pcc:restart
bind pub n|- ${pcc_char}reload pcc:reload
bind pub n|- ${pcc_char}save pcc:save
bind pub n|- ${pcc_char}backup pcc:backup
bind pub n|- ${pcc_char}die pcc:die

bind pub n|n ${pcc_char}jump pcc:jump

proc pcc:adduser {nick host hand chan text} {
   if {![pcc:ok_usr $nick $chan 0]} { return 0 }
   set _who [pcc:getarg $text]
   if {![validuser $_who]} {
      putcmdlog "<<$nick>> !$hand! adduser $_who"
      adduser $_who
   }
}

proc pcc:deluser {nick host hand chan text} {
   if {![pcc:ok_usr $nick $chan 0]} { return 0 }
   set _who [pcc:getarg $text]
   if {[validuser $_who]} {
      putcmdlog "<<$nick>> !$hand! deluser $_who"
      deluser $_who
   }
}

proc pcc:addhost {nick host hand chan text} {
   if {![pcc:ok_usr $nick $chan 0]} { return 0 }
   set _who [pcc:getarg $text]
   if {[validuser $_who]} {
      set _host [pcc:getarg $text 1]
      putcmdlog "<<$nick>> !$hand! addhost $_who $_host"
      setuser $_who HOSTS $_host
   }
}

proc pcc:op {nick host hand chan text} {
   if {![pcc:ok_bot $chan]} { return 0 }
   if {[llength $text] < 1 && ![isop $nick $chan]} {
      putcmdlog "<<$nick>> !$hand! op $chan $nick"
      pushmode $chan +o $nick
      #flushmode $chan
   } else {
      set _who ""
      foreach _nick [split [pcc:strcln $text]] {
         if {[onchan $_nick $chan] && ![isop $_nick $chan]} {
            append _who "$_nick "
            pushmode $chan +o $_nick
         }
      }
      #if {$_who ne ""} {
         putcmdlog "<<$nick>> !$hand! op $chan [string trimright $_who] ($text)"
         #flushmode $chan
      #}
   }
}

proc pcc:deop {nick host hand chan text} {
   if {![pcc:ok_bot $chan]} { return 0 }
   if {[llength $text] < 1 && [isop $nick $chan]} {
      putcmdlog "<<$nick>> !$hand! deop $chan $nick"
      pushmode $chan -o $nick
      #flushmode $chan
   } else {
      set _who ""
      set _lvl [pcc:getlvl $hand $chan]
      foreach _nick [split [pcc:strcln $text]] {
         if {[onchan $_nick $chan] && ![isbotnick $_nick] && [isop $_nick $chan]} {
            if {$_lvl >= [pcc:getlvl [nick2hand $_nick] $chan]} {
               append _who "$_nick "
               pushmode $chan -o $_nick
            }
         }
      }
      #if {$_who ne ""} {
         putcmdlog "<<$nick>> !$hand! deop $chan [string trimright $_who] ($text)"
         #flushmode $chan
      #}
   }
}

proc pcc:voice {nick host hand chan text} {
   if {![pcc:ok_bot $chan]} { return 0 }
   if {[llength $text] < 1 && ![isop $nick $chan] && ![isvoice $nick $chan]} {
      putcmdlog "<<$nick>> !$hand! voice $chan $nick"
      pushmode $chan +v $nick
      #flushmode $chan
   } else {
      set _who ""
      foreach _nick [split [pcc:strcln $text]] {
         if {[onchan $_nick $chan] && ![isop $_nick $chan] && ![isvoice $_nick $chan]} {
            append _who "$_nick "
            pushmode $chan +v $_nick
         }
      }
      #if {$_who ne ""} {
         putcmdlog "<<$nick>> !$hand! voice $chan [string trimright $_who] ($text)"
         #flushmode $chan
      #}
   }
}

proc pcc:devoice {nick host hand chan text} {
   if {![pcc:ok_bot $chan]} { return 0 }
   if {[llength $text] < 1 && [isvoice $nick $chan]} {
      putcmdlog "<<$nick>> !$hand! devoice $chan $nick"
      pushmode $chan -v $nick
      #flushmode $chan
   } else {
      set _who ""
      foreach _nick [split [pcc:strcln $text]] {
         if {[onchan $_nick $chan] && [isvoice $_nick $chan]} {
            append _who "$_nick "
            pushmode $chan -v $_nick
         }
      }
      #if {$_who ne ""} {
         putcmdlog "<<$nick>> !$hand! devoice $chan [string trimright $_who] ($text)"
         #flushmode $chan
      #}
   }
}

proc pcc:kick {nick host hand chan text} {
   if {![pcc:ok_bot $chan] || [llength $text] < 1} { return 0 }
   set _text [split [string trim $text]]
   set _who [lindex $_text 0]
   if {[onchan $_who $chan] && ![isbotnick $_who]} {
      if {[llength $_text] > 1} {
         set _reason "[join [lrange $_text 1 end]] - "
      }
      append _reason "requested by: $nick"
      if {[pcc:getlvl $hand $chan] >= [pcc:getlvl [nick2hand $_who] $chan]} {
         putcmdlog "<<$nick>> !$hand! kick $chan $_who $_reason"
         putkick $chan $_who $_reason
      }
   }
}

proc pcc:topic {nick host hand chan text} {
   if {![pcc:ok_bot $chan] || [llength $text] < 1} { return 0 }
   putcmdlog "<<$nick>> !$hand! topic $chan $text"
   putserv "TOPIC $chan :$text"
}

proc pcc:mode {nick host hand chan text} {
   if {![pcc:ok_bot $chan] || [llength $text] < 1} { return 0 }
   set _mode [lrange [split [pcc:strcln $text]] 0 6]
   putcmdlog "<<$nick>> !$hand! mode $chan $_mode"
   putserv "MODE $chan :$_mode"
}

proc pcc:shutup {nick host hand chan text} {
   if {![pcc:ok_bot $chan] || [llength $text] < 1} { return 0 }
   set _who [pcc:getarg $text]
   if {$_who ne "" && [onchan $_who $chan] && ![isbotnick $_who] && $_who != $nick} {
      if {![isvoice $nick $chan] && ![isop $nick $chan]} {
         pushmode $chan +v $nick
      }
      if {[isvoice $_who $chan]} {
         pushmode $chan -v $_who
      }
      if {[isop $_who $chan]} {
         pushmode $chan -o $_who
      }
      pushmode $chan +m
      putcmdlog "<<$nick>> !$hand! shutup $chan $_who"
   }
}

proc pcc:lock {nick host hand chan text} {
   if {![pcc:ok_bot $chan]} { return 0 }
   putcmdlog "<<$nick>> !$hand! mode $chan +im"
   pushmode $chan +im
}

proc pcc:unlock {nick host hand chan text} {
   if {![pcc:ok_bot $chan]} { return 0 }
   putcmdlog "<<$nick>> !$hand! mode $chan -im"
   pushmode $chan -im
}

proc pcc:ban {nick host hand chan text} {
   if {![pcc:ok_bot $chan] || [llength $text] < 1} { return 0 }
   set _text [split [string trim $text]]
   set _who [lindex $_text 0]
   if {[isbotnick $_who]} { return 0 }
   if {[onchan $_who $chan]} {
      if {[pcc:getlvl $hand $chan] >= [pcc:getlvl [nick2hand $_who] $chan]} {
         set _mask [maskhost [getchanhost $_who $chan]]
         #set _mask "*!*[lindex [split $_mask "!"] 1]"
      }
   } else {
      set _mask $_who
   }
   if {[llength $_text] > 1} {
      set _reason "[join [lrange $_text 1 end]] - "
   }
   append _reason "requested by: $nick"
   putcmdlog "<<$nick>> !$hand! ban $text"
   newchanban $chan $_mask $nick $_reason
}

proc pcc:kban {nick host hand chan text} {
   if {![pcc:ok_bot $chan] || [llength $text] < 1} { return 0 }
   set _text [split [string trim $text]]
   set _who [lindex $_text 0]
   if {[isbotnick $_who]} { return 0 }
   if {[onchan $_who $chan]} {
      if {[pcc:getlvl $hand $chan] >= [pcc:getlvl [nick2hand $_who] $chan]} {
         set _mask [maskhost [getchanhost $_who $chan]]
         #set _mask "*!*[lindex [split $_mask "!"] 1]"
         if {[llength $_text] > 1} {
            set _reason "[join [lrange $_text 1 end]] - "
         }
         append _reason "requested by: $nick"
         putcmdlog "<<$nick>> !$hand! kickban $text"
         newchanban $chan $_mask $nick $_reason
         putkick $chan $_who $_reason
      }
   }
}

proc pcc:unban {nick host hand chan text} {
   if {![pcc:ok_bot $chan] || [llength $text] < 1} { return 0 }
   set _mask [pcc:getarg $text]
   if {![ischanban $_mask $chan]} { return 0 }
   putcmdlog "<<$nick>> !$hand! unban $chan $_mask"
   killchanban $chan $_mask
   #pushmode $chan -b $_mask
}

proc pcc:rehash {nick host hand chan text} {
   if {![pcc:ok_usr $nick $chan]} { return 0 }
   putcmdlog "<<$nick>> !$hand! rehash"
   rehash
}

proc pcc:restart {nick host hand chan text} {
   if {![pcc:ok_usr $nick $chan]} { return 0 }
   putcmdlog "<<$nick>> !$hand! restart"
   restart
}

proc pcc:backup {nick host hand chan text} {
   if {![pcc:ok_usr $nick $chan]} { return 0 }
   putcmdlog "<<$nick>> !$hand! backup"
   backup
}

proc pcc:save {nick host hand chan text} {
   if {![pcc:ok_usr $nick $chan]} { return 0 }
   putcmdlog "<<$nick>> !$hand! save"
   save
}

proc pcc:reload {nick host hand chan text} {
   if {![pcc:ok_usr $nick $chan]} { return 0 }
   putcmdlog "<<$nick>> !$hand! reload"
   reload
}

proc pcc:die {nick host hand chan text} {
   if {![pcc:ok_usr $nick $chan]} { return 0 }
   if {[llength $text] < 1} { set text "requested by: $nick" }
   putcmdlog "<<$nick>> !$hand! die $text"
   die $text
}

proc pcc:jump {nick host hand chan text} {
   if {![pcc:ok_usr $nick $chan]} { return 0 }
   set _srv [pcc:getarg $text]
   putcmdlog "<<$nick>> !$hand! jump $_srv"
   jump $_srv
}

proc pcc:ulimit {nick host hand chan text} {
   if {![pcc:ok_bot $chan]} { return 0 }
   putcmdlog "<<$nick>> !$hand! limit $chan -l"
   pushmode $chan -l
}

proc pcc:getlvl {hand chan} {
   set _lvl 0
   if {$hand ne "*" && $hand ne ""} {
      if {[matchattr $hand v|v $chan]} { set _lvl [expr {$_lvl | 0x01}] }
      if {[matchattr $hand o|o $chan]} { set _lvl [expr {$_lvl | 0x02}] }
      if {[matchattr $hand -|m $chan]} { set _lvl [expr {$_lvl | 0x04}] }
      if {[matchattr $hand m|- $chan]} { set _lvl [expr {$_lvl | 0x08}] }
      if {[matchattr $hand -|n $chan]} { set _lvl [expr {$_lvl | 0x10}] }
      if {[matchattr $hand n|- $chan]} { set _lvl [expr {$_lvl | 0x20}] }
      if {[matchattr $hand f|f $chan]} { set _lvl [expr {$_lvl | 0x40}] }
   }
   return $_lvl
}

proc pcc:ok_bot {chan {needop 1}} {
   if {[channel get $chan chancmds] != 1} { return 0 }
   if {$needop && ![botisop $chan]} { return 0 }
   return 1
}

proc pcc:ok_usr {nick chan {needop 1}} {
   if {[channel get $chan chancmds] != 1} { return 0 }
   if {$needop && ![isop $nick $chan]} { return 0 }
   return 1
}

proc pcc:strcln {text} {
   return [string trim [regsub -all -- " +" $text " "]]
}

proc pcc:getarg {text {idx 0}} {
   return [lindex [split [pcc:strcln $text]] $idx]
}

putlog "Public Channel Commands v1.8 by wilk"
Ostatnio edytowano 11 listopada 2017, 02:53 przez wilk, łącznie edytowano 14 razy
Powód: aktualizacja skryptów
Avatar użytkownika
wilk
Ascendant
Ascendant
 
Posty: 1634
Dołączył(a): 30 lipca 2005, 16:32
Lokalizacja: #QuizPL @ IRCnet
Płeć: Mężczyzna

Powrót do O #QuizPL

Kto przegląda forum

Użytkownicy przeglądający ten dział: Brak zidentyfikowanych użytkowników i 1 gość