Pushmode
From Scriptwiki
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; PUSHMODE ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;info:
;
; by wiebe @ QuakeNet
; version 1.31 (written and tested on mIRC 6.15)
;
; last edit: Fri Apr 30 2004
;
;
;What does this script do?
;
; Queues and dumps modes together as much as possible.
;
;
;Some examples:
;
; Example 1: from within same command
; voicing some users with the following command:
; //var %x = $nick($chan,0,r) | while (%x) { mode $chan +v $nick($chan,%x,r) | dec %x }
; and this happens:
;
; [18:45:32] * dev-mirc sets mode: +v zyrtepf
; [18:45:32] * dev-mirc sets mode: +v zcttchv
; [18:45:32] * dev-mirc sets mode: +v yznzko
; [18:45:32] * dev-mirc sets mode: +v yuxf
; [18:45:32] * dev-mirc sets mode: +v twyqh
; [18:45:34] * dev-mirc sets mode: +v pitqxpg
; [18:45:36] * dev-mirc sets mode: +v nsln
; [18:45:38] * dev-mirc sets mode: +v moypfnk
; [18:45:40] * dev-mirc sets mode: +v gibuhee
; [18:45:42] * dev-mirc sets mode: +v evuwntm
;
; This sends a mode command +v <nick> for each nick
;
; Now we do the same but with pushmode instead of the normal mode command:
; //var %x = $nick($chan,0,r) | while (%x) { pushmode $chan +v $nick($chan,%x,r) | dec %x }
; and this happens:
;
; [18:48:03] * dev-mirc sets mode: +vvvvvv zyrtepf zcttchv yznzko yuxf twyqh pitqxpg
; [18:48:04] * dev-mirc sets mode: +vvvv nsln moypfnk gibuhee evuwntm
;
; The modes were now pushed together, so only 2 mode commands are needed instead of 10
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Example 2: the same event repeated
; An normal anti-flood script for example does this:
;
; [18:23:32] <zcttchv> AVERAGE ANTI FLOOD SCRIPT WITHOUT PUSHMODE
; [18:23:32] <evuwntm> AVERAGE ANTI FLOOD SCRIPT WITHOUT PUSHMODE
; [18:23:32] <moypfnk> AVERAGE ANTI FLOOD SCRIPT WITHOUT PUSHMODE
; [18:23:33] <zyrtepf> AVERAGE ANTI FLOOD SCRIPT WITHOUT PUSHMODE
; [18:23:33] <gibuhee> AVERAGE ANTI FLOOD SCRIPT WITHOUT PUSHMODE
; [18:23:33] <yznzko> AVERAGE ANTI FLOOD SCRIPT WITHOUT PUSHMODE
; [18:23:33] <yuxf> AVERAGE ANTI FLOOD SCRIPT WITHOUT PUSHMODE
; [18:23:33] <pitqxpg> AVERAGE ANTI FLOOD SCRIPT WITHOUT PUSHMODE
; [18:23:33] <nsln> AVERAGE ANTI FLOOD SCRIPT WITHOUT PUSHMODE
; [18:23:33] <twyqh> AVERAGE ANTI FLOOD SCRIPT WITHOUT PUSHMODE
; [18:23:33] * dev-mirc sets mode: +b *!*qgeqd@8V5Ry4.8vtU30.virtual
; [18:23:33] * dev-mirc sets mode: +b *!*ihgkzu@8V5Ry4.8vtU30.virtual
; [18:23:33] * dev-mirc sets mode: +b *!*dqqyex@8V5Ry4.8vtU30.virtual
; [18:23:36] * dev-mirc sets mode: +b *!*qfzzq@8V5Ry4.8vtU30.virtual
; [18:23:40] * dev-mirc sets mode: +b *!*alavec@8V5Ry4.8vtU30.virtual
; [18:23:44] * dev-mirc sets mode: +b *!*avwy@8V5Ry4.8vtU30.virtual
; [18:23:48] * dev-mirc sets mode: +b *!*tqkukhp@8V5Ry4.8vtU30.virtual
; [18:23:52] * dev-mirc sets mode: +b *!*xrvdohn@8V5Ry4.8vtU30.virtual
; [18:23:56] * dev-mirc sets mode: +b *!*ujundvh@8V5Ry4.8vtU30.virtual
; [18:24:00] * dev-mirc sets mode: +b *!*kid@8V5Ry4.8vtU30.virtual
;
; The anti-flood script sends each ban with a mode command
;
; The same script using pushmode does the following:
;
; [18:25:11] <zcttchv> AVERAGE ANTI FLOOD SCRIPT WITH PUSHMODE
; [18:25:11] <evuwntm> AVERAGE ANTI FLOOD SCRIPT WITH PUSHMODE
; [18:25:11] <moypfnk> AVERAGE ANTI FLOOD SCRIPT WITH PUSHMODE
; [18:25:11] <zyrtepf> AVERAGE ANTI FLOOD SCRIPT WITH PUSHMODE
; [18:25:11] <gibuhee> AVERAGE ANTI FLOOD SCRIPT WITH PUSHMODE
; [18:25:11] <yznzko> AVERAGE ANTI FLOOD SCRIPT WITH PUSHMODE
; [18:25:11] <yuxf> AVERAGE ANTI FLOOD SCRIPT WITH PUSHMODE
; [18:25:11] <pitqxpg> AVERAGE ANTI FLOOD SCRIPT WITH PUSHMODE
; [18:25:11] <nsln> AVERAGE ANTI FLOOD SCRIPT WITH PUSHMODE
; [18:25:12] <twyqh> AVERAGE ANTI FLOOD SCRIPT WITH PUSHMODE
; [18:25:12] * dev-mirc sets mode: +bbbbbb *!*qgeqd@8V5Ry4.8vtU30.virtual *!*ihgkzu@8V5Ry4.8vtU30.virtual *!*dqqyex@8V5Ry4.8vtU30.virtual *!*qfzzq@8V5Ry4.8vtU30.virtual *!*alavec@8V5Ry4.8vtU30.virtual *!*avwy@8V5Ry4.8vtU30.virtual
; [18:25:13] * dev-mirc sets mode: +bbbb *!*tqkukhp@8V5Ry4.8vtU30.virtual *!*xrvdohn@8V5Ry4.8vtU30.virtual *!*ujundvh@8V5Ry4.8vtU30.virtual *!*kid@8V5Ry4.8vtU30.virtual
;
; The anti-flood script sends the modes to pushmode, which turns 10 mode commands into 2
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; Example 3: multiple events
; Some form of a bitchmode script:
;
; on @!*:op:#channel:{ if ($opnick != $me) { mode $chan -o $opnick } }
; on @!*:voice:#channel:{ if ($vnick != $me) { mode $chan -v $vnick } }
; on @!*:help:#channel:{ if ($hnick != $me) { mode $chan -h $hnick } }
; on @!*:mode:#channel:{
; if (n isincs $1) && (n !isincs $gettok($chan($chan).mode,1,32)) { mode $chan +n }
; if (t isincs $1) && (t !isincs $gettok($chan($chan).mode,1,32)) { mode $chan +t }
; }
;
; [13:54:31] * wiebe sets mode: -nt+ovh nick1 nick2 nick3
; [13:54:31] * dev-mirc sets mode: +n
; [13:54:31] * dev-mirc sets mode: +t
; [13:54:31] * dev-mirc sets mode: -o nick1
; [13:54:31] * dev-mirc sets mode: -v nick2
; [13:54:31] * dev-mirc sets mode: -h nick3
;
; With pushmode:
;
; on @!*:op:#channel:{ if ($opnick != $me) { pushmode $chan -o $opnick } }
; on @!*:voice:#channel:{ if ($vnick != $me) { pushmode $chan -v $vnick } }
; on @!*:help:#channel:{ if ($hnick != $me) { pushmode $chan -h $hnick } }
; on @!*:mode:#channel:{
; if (n isincs $1) && (n !isincs $gettok($chan($chan).mode,1,32)) { pushmode $chan +n }
; if (t isincs $1) && (t !isincs $gettok($chan($chan).mode,1,32)) { pushmode $chan +t }
; }
;
; [13:55:36] * wiebe sets mode: -nt+ohv nick1 nick2 nick3
; [13:55:36] * dev-mirc sets mode: -ohv+nt nick1 nick2 nick3
;
; only 1 mode line needed for the 4 events
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
;
;How to use this script?
;
; pushmode [-cdflnprswuNeM] <channel> <+/-mode> [arg]
;
; can be used to push channel modes together, see below
;
;
; The script has 4 different queue's,
; a queue for single modes (like +m) is emptied everytime pushmode is sending modes
; a faster queue, a normal queue (default) and a slower queue for modes with a parameter (like +b banmask)
; first the faster queue is emptied, then the default queue and last the slower queue
;
; The -n switch (next) queues the mode in the faster queue, the -l switch (low) can be used for the slower queue
; this is only for modes with a parameter
; pushmode #channel +v nick adds +v nick to the default queue
; pushmode -l #channel -v nick adds -v nick to the slower queue
; pushmode -n #channel +o nick adds +o nick to the faster queue
;
; The -c switch (clear) can be used to clear the queues
; the -l (low), -d (default), -n (next) and -s (single) switch
; can be used to clear a specific queue or multiple queues
; pushmode -c clears all queues for all channels
; pushmode -dc clears the default queue for all channels
; pushmode -nc #channel clears the faster queue for #channel
; pushmode -cs #channel clears the single queue for #channel
; pushmode -cdl #channel clears the default and slower queue for #channel
;
; The -f switch (flush) starts to empty the queue at once without waiting for the timer to start it
; pushmode -f starts pushmode for all channels
; pushmode -f #channel starts pushmode for #channel
; pushmode -f #channel +o nick starts pushmode for #channel after adding +o nick to the queue
;
; The -p switch (passive) can be used to only add a mode to the queue,
; but it will not cause pushmode to empty the queue,
; this mode will be send the next time pushmode is dumping modes
; or when the number of modes in the queues equals $modespl
; pushmode -p #channel +b queues in the default queue and
; sends +b (request banlist) the next time pushmode is dumping modes
; pushmode -p #channel -b *!*@host.com queues in the default queue and
; sends -b *!*@host.com the next chance it gets
;
; The -r switch (remove) removes a mode from the queue,
; the -l (low), -d (default) and -n (next) switch
; can be used to remove a mode from a specific queue or from multiple queues
; when combined with the -w a wildcardmatch is done
; if you want to clear the entire queue, it is better (read faster) to use the -c switch
; usefull when you want to set a key with pushmode and you first clear any +k and -k modes
; pushmode -dr #channel +b *!*@host.com removes +b *!*@host.com from the default queue
; pushmode -r #channel +v nick removes +v nick from all queues
; pushmode -rw #channel +b * removes all bans from all queues
; pushmode -rw #channel +? removes all single + modes from the queue
; pushmode -rdl #channel +k key removes +k key from the default and slower queue
;
; The -uN switch can be used to remove a ban after N seconds using pushmode
; using 0 for N, makes the script remove the ban from the internal tempban list
; this will not remove the ban from the channel
; pushmode -u120 #channel +b *!*@host.com removes the ban *!*@host.com after 120 seconds
; pushmode -u0 #channel +b *!*@leave.this.ban removes *!*@leave.this.ban from the internal tempban list
;
; The -eM switch (expire) removes the mode from the queue after M seconds,
; so if the mode is not send within M seconds, it will not be send
; pushmode -e10 #channel +m mode +m will only be send within 10 seconds or not
; pushmode -e60 #channel +l 100 mode +l 100 will only be send within 60 seconds or not
;
; Combinations are possible, for example:
; pushmode -nfpe60u600 #channel +b *!*user@*.host.com
;
; The script can voice/devoice users even if they changed nick since the mode was in the queue
; this can be done by giving nick!user@host as parameter
; the default settings makes the script understand that @%+ is ohv, if you are on a server with additional
; modes which can be set on users on a channel, you have to edit the prefix setting below
; the target needs to be in your IAL list for this to work
; the script adds/removes a tag to the IAL using ialmark and finds the nick when sending the mode
; other scripts using ialmark may break this part
;
; pushmode #channel +v goober!~bla@123.abc.isp.com will voice the user goober, even if he would
; change nick before the mode is send
;
; pushmode #channel -h somenick!someuser@abc.users.undernet.org dehalfops somenick, even if he would
; change nick before the mode is send
;
; pushmode #channel +o dev-mirc!dev-mirc@def.users.quakenet.org will op dev-mirc, even if he would
; change nick before the mode is send
;
;
; pushuser <+/-mode> [arg]
;
; can be used for usermodes, usefull if you have several scripts setting usermodes on connect
; pushuser will send them all at once instead of N times a mode command
;
;
; Pushmode (pushuser) can only take 1 mode at a time
; The - or + needs to be included
; The script does not allow duplicates in the same queue
; Temp bans work only if nick!user@host format is used (like *!*@host.com and not *host.com or just host.com)
; this is because of the isban operator
;
; Script is uses $modespl (MODES= setting),
; here meaning how many parameter modes (like +b banmask) can be put into 1 line
; the number of modes without parameter (like +m) is unlimited
; if you want to use this script on a server where this is different, you have to change the script a bit
; see the pushmode.dump alias
;
; Some checks are done on the modes, like if the mode exists, if the mode makes "sense" etc.
; it uses $chanmodes (with b,k,l,imnpst as default modes), checks op/halfop status.
; you can see the checks and change them in the pushmode.dump alias
;
;
;What use has this script?
;
; not only can you simply 'queue' mode changes from within the same event or script
; but mode changes by all scripts can be pushed together
;
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS PUSHMODE.DELAY ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; when first called, the script will wait N seconds before sending a mode change
alias -l pushmode.delay {
return 1
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS PUSHMODE.RESTART ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; set here the delay (seconds) pushmode should have between multiple mode lines
; after sending a mode change and there are items left in the queue,
; it will wait N seconds before sending the next mode change
alias -l pushmode.restart {
return 2
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS PUSHMODE.BAN ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; set here the delay (seconds) for checking which bans are to be unset
; a timer runs with this interval
; it checks the temp bans set by this script for all channels and unbans them with pushmode
; settings this to 600 (10 min) for example, makes a temp ban set for 5min being unset after 5~15 minutes
; so this setting defines how accurate the time of a temp ban is
alias -l pushmode.ban {
return 600
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS PUSHMODE.PREFIX ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; set here what modes can be set on a user on a channel (this is NOT b or any other list mode)
; default @ = o, % = h, + = v
; leave empty if you dont want to use this
; if you are not sure what this is, leave it
; replace each char with their mode char, @ is o for example
alias -l pushmode.prefix {
return $nickmode
; should $nickmode not work, remove it and use the following line
return $replace($prefix,@,o,%,h,+,v)
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS PUSHMODE ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; pushmode [-cdflnprswuNeM] <channel> <+/-mode> [arg]
alias pushmode {
var %f, %q, %p, %e, %u
; part for switches
if ($left($1,1) == -) {
; c switch is there
if (c isin $1) {
; no channel
if (!$2) {
; d switch is there, clear all default queues for this connection
if (d isin $1) { $pushmode.queue($+($cid,.pushmode.*.default)).clear }
; n switch is there, clear all next queues for this connection
if (n isin $1) { $pushmode.queue($+($cid,.pushmode.*.next)).clear }
; l switch is there, clear all low queues for this connection
if (l isin $1) { $pushmode.queue($+($cid,.pushmode.*.low)).clear }
; s switch is there, clear all single queues for this connection
if (s isin $1) { $pushmode.queue($+($cid,.pushmode.*.single)).clear }
; no other switches, clear all queues for this connection
if (n !isin $1) && (d !isin $1) && (l !isin $1) && (s !isin $1) { $pushmode.queue($+($cid,.pushmode.*)).clear }
}
else {
; d switch is there, clear the default queue for the channel
if (d isin $1) { $pushmode.queue($+($cid,.pushmode.,$hash($2,32),.default)).clear }
; n switch is there, clear the next queue for the channel
if (n isin $1) { $pushmode.queue($+($cid,.pushmode.,$hash($2,32),.next)).clear }
; l switch is there, clear the low queue for the channel
if (l isin $1) { $pushmode.queue($+($cid,.pushmode.,$hash($2,32),.low)).clear }
; s switch is there, clear the single queue for this connection
if (s isin $1) { $pushmode.queue($+($cid,.pushmode.,$hash($2,32),.single)).clear }
; no other switches, clear all queues for the channel
if (n !isin $1) && (d !isin $1) && (l !isin $1) && (s !isin $1) {
$pushmode.queue($+($cid,.pushmode.,$hash($2,32),.next)).clear
$pushmode.queue($+($cid,.pushmode.,$hash($2,32),.default)).clear
$pushmode.queue($+($cid,.pushmode.,$hash($2,32),.low)).clear
$pushmode.queue($+($cid,.pushmode.,$hash($2,32),.single)).clear
}
}
return
}
; f switch is there, set a var
if (f isin $1) { var %f = 1 }
; n switch is there, set a var
if (n isin $1) { var %q = next }
; l switch is there, set a var
elseif (l isin $1) { var %q = low }
; p switch is there, set a var
if (p isin $1) { var %p = 1 }
; u or e switch is used, set a var
if (u isin $1) || (e isin $1) { var %string = $remove($1,-,d,c,f,l,n,p,r,s,w) , %x = 1
; loop through all chars
while (%x <= $len(%string)) {
; found u, set a var
if ($mid(%string,%x,1) == u) { var %y = $calc(%x +1)
; as long as it is numbers, set a var, next char
while ($mid(%string,%y,1) isnum) { var %u = %u $+ $mid(%string,%y,1) | inc %y }
}
; found e, set a var
if ($mid(%string,%x,1) == e) { var %y = $calc(%x +1)
; as long as it is numbers, set a var, next char
while ($mid(%string,%y,1) isnum) { var %e = %e $+ $mid(%string,%y,1) | inc %y }
}
inc %x
}
; '%e' is a number, set a var
if (%e isnum) { var %e = -e $+ %e }
}
; u switch is there with a number, +b and a banmask, add to the hash table, make it decrease each second
if (u isin $1) && ($3 == +b) && ($4) && (%u > 0) {
hadd -m $+($cid,.pushmode.,$hash($2,32),.bans) $4 %u | hdec -c $+($cid,.pushmode.,$hash($2,32),.bans) $4
; check the timer, start the timer
if (!$timer($+($cid,.pushmode.bans))) {
.timer $+ $cid $+ .pushmode.bans 1 $$pushmode.ban pushmode.tempban
}
}
; number with u is 0
if (%u == 0) && ($3 == +b) && ($4) {
; check if it is already in the hash table as temp ban, delete it
if ($hget($+($cid,.pushmode.,$hash($2,32),.bans))) && ($hget($+($cid,.pushmode.,$hash($2,32),.bans),$4)) {
hdel $+($cid,.pushmode.,$hash($2,32),.bans) $4
; check if the hash table is empty, free the hash table
if ($hget($+($cid,.pushmode.,$hash($2,32),.bans),0).item == 0) {
hfree $+($cid,.pushmode.,$hash($2,32),.bans)
}
}
return
}
; r switch is there and mode '$3'
if (r isin $1) && ($3) {
; w switch is there
if (w isin $1) {
; no parameter, remove the mode from the single queue
if ($4 == $null) { pushmode.queue -rw $+($cid,.pushmode.,$hash($2,32),.single) $3 }
else {
; d switch is there, remove the mode from the default queue
if (d isin $1) { pushmode.queue -rw $+($cid,.pushmode.,$hash($2,32),.default) $3-4 }
; n switch is there, remove the mode from the next queue
if (n isin $1) { pushmode.queue -rw $+($cid,.pushmode.,$hash($2,32),.next) $3-4 }
; l switch is there, remove the mode from the low queue
if (l isin $1) { pushmode.queue -rw $+($cid,.pushmode.,$hash($2,32),.low) $3-4 }
; no other switch is there, remove the mode from all queues
if (n !isin $1) && (d !isin $1) && (l !isin $1) {
pushmode.queue -rw $+($cid,.pushmode.,$hash($2,32),.next) $3-4 | pushmode.queue -rw $+($cid,.pushmode.,$hash($2,32),.low) $3-4 | pushmode.queue -rw $+($cid,.pushmode.,$hash($2,32),.default) $3-4
}
}
}
else {
; no parameter, remove mode from the single queue
if ($4 == $null) { pushmode.queue -r $+($cid,.pushmode.,$hash($2,32),.single) $3 }
else {
; d switch is there, remove mode form the default queue
if (d isin $1) { pushmode.queue -r $+($cid,.pushmode.,$hash($2,32),.default) $3-4 }
; n switch is there, remove mode form next queue
if (n isin $1) { pushmode.queue -r $+($cid,.pushmode.,$hash($2,32),.next) $3-4 }
; l switch is there, remove mode form the low queue
if (l isin $1) { pushmode.queue -r $+($cid,.pushmode.,$hash($2,32),.low) $3-4 }
; no other switch is there, remove mode form all queues
if (n !isin $1) && (d !isin $1) && (l !isin $1) && (s !isin $1) {
pushmode.queue -r $+($cid,.pushmode.,$hash($2,32),.next) $3-4 | pushmode.queue -r $+($cid,.pushmode.,$hash($2,32),.low) $3-4 | pushmode.queue -r $+($cid,.pushmode.,$hash($2,32),.default) $3-4
}
}
}
return
}
tokenize 32 $2-
}
; leave multiple modes out
tokenize 32 $1 $left($2,2) $3
; '$2' starts with '+' or with '-', we are on channel '$1'
if ($istok(+ -,$left($2,1),32)) && ($me ison $1) {
; '$3' does exist
if ($3 != $null) {
; -n switch was used, queue mode '$2 $3' in the next queue
if (%q == next) { pushmode.queue %e $+($cid,.pushmode.,$hash($1,32),.next) $2-3 }
; -l switch was used, queue mode '$2 $3' in the low queue
elseif (%q == low) { pushmode.queue %e $+($cid,.pushmode.,$hash($1,32),.low) $2-3 }
; use default queue, queue mode '$2 $3' in the 'default' queue
else { pushmode.queue %e $+($cid,.pushmode.,$hash($1,32),.default) $2-3 }
}
; the mode does not have a parameter, queue mode '$2' it in the single queue
else { pushmode.queue $+($cid,.pushmode.,$hash($1,32),.single) $2 }
; check if the timer is not already running and check the -p switch, start the timer
if (!$timer($+($cid,.pushmode.,$hash($1,32)))) && (%p != 1) {
.timer $+ $cid $+ .pushmode. $+ $hash($1,32) 1 $$pushmode.delay pushmode.dump $1
}
; no timer, and passive switch, set a var
if (!$timer($+($cid,.pushmode.,$hash($1,32)))) && (%p == 1) {
var %x = 1, %queue = .next .default .low, %q = 1, %t = 0
; loop through each queue, inc var, next queue
while ($gettok(%queue,%q,32)) {
inc %t $pushmode.queue($+($cid,.pushmode.,$hash($1,32),$gettok(%queue,%q,32))).size | inc %q
}
; at least $modespl modes in the queues, start the timer
if (%t >= $modespl) {
.timer $+ $cid $+ .pushmode. $+ $hash($1,32) 1 $$pushmode.delay pushmode.dump $1
}
}
; f switch was used
if (%f == 1) {
; no channel, set a var
if (!$1) { var %x = $chan(0)
; loop through all the channels, stop the timer, run 'pushmode.dump chan', decrease '%x' and go on to the next channel
while (%x) {
.timer $+ $+($cid,.pushmode.,$hash($chan(%x),32)) off | pushmode.dump $chan(%x) | dec %x
}
}
; we are on '$1', stop the timer, run 'pushmode.dump $1'
elseif ($me ison $1) {
.timer $+ $+($cid,.pushmode.,$hash($1,32)) off | pushmode.dump $1
}
}
}
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS PUSHMODE.DUMP ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; $1 = #channel
alias -l pushmode.dump {
; we are on channel '$1', set vars
if ($me ison $1) { var %x = 1, %queue = .next .default .low, %q = 1, %mode, %check, %smode
; loop through each queue
while ($gettok(%queue,%q,32)) {
; we loop as long as '%x' <= '$modespl' and as long as the size of the queue is greater then 0
while (%x <= $modespl) && ($pushmode.queue($+($cid,.pushmode.,$hash($1,32),$gettok(%queue,%q,32))).size > 0) {
; save the next item in a var
var %next = $pushmode.queue($+($cid,.pushmode.,$hash($1,32),$gettok(%queue,%q,32))).next
; check if mode is not already going to be set
if (!$istokcs(%check,%next,44)) && (%next) { var %1 = $gettok(%next,1,32), %2 = $gettok(%next,2,32)
; some checks / examples of checks
if (%1 === +o) && (%2 isop $1) { }
elseif (%1 === -o) && (%2 !isop $1) { }
elseif (%1 === +h) && (%2 ishop $1) { }
elseif (%1 === -h) && (%2 !ison $1) { }
elseif (%1 === +v) && (%2 isvoice $1) { }
elseif (%1 === -v) && (%2 !ison $1) { }
elseif (%1 === +b) && (%2 isban $1) { }
elseif (%1 === +l) && ((%2 !isnum) || (%2 < 1)) { }
elseif (%1 === +l) && (%2 == $chan($1).limit) { }
elseif (%1 === +k) && ($chan($1).key) { }
elseif (%1 === -k) && (%2 !=== $chan($1).key) { }
elseif ($right(%1,1) === o) && ($me !isop $1) { }
elseif ($right(%1,1) === h) && ($me !isop $1) { }
elseif ($me !isop $1) && ($me !ishop $1) { }
; add '%next' to '%check', add the mode in the var
else { var %check = $addtok(%check,%next,44) | var %mode = $+($gettok(%mode,1,32),$gettok(%next,1,32)) $gettok(%mode,2-,32) $gettok(%next,2,32) }
inc %x
}
}
inc %q
}
; we loop as long as the size of the single queue is greater then 0, set vars
while ($pushmode.queue($+($cid,.pushmode.,$hash($1,32),.single)).size > 0) {
var %next = $pushmode.queue($+($cid,.pushmode.,$hash($1,32),.single)).next
var %a = $+($gettok($chanmodes,1,44),b), %b = $+($gettok($chanmodes,2,44),k)
var %c = $+($gettok($chanmodes,3,44),l), %d = $+($gettok($chanmodes,4,44),imnpst)
; some checks / examples of checks
if ($right(%next,1) isincs %b) { }
elseif ($right(%next,1) isincs %c) && ($left(%next,1) == +) { }
elseif ($right(%next,1) isincs %b) { }
elseif ($me !isop $1) && ($me !ishop $1) && ($right(%next,1) !isincs %a) { }
; add next mode to the var
else { var %smode = $+(%smode,%next) }
}
; if the ibl isnt filled for that channel, add +b to request the banlist
; if you want this uncomment the following line
;if (b !isincs %smode) && (!$chan($1).ibl) { var %smode = $+(%smode,+b) }
; add the mode in the var
var %mode = $+($gettok(%mode,1,32),%smode) $gettok(%mode,2-,32)
; there are modes in '%mode', send the modes
if (%mode) { .quote MODE $1 %mode }
var %q = 1
; loop through the queues
while ($gettok(%queue,%q,32)) {
; items left, break
if ($pushmode.queue($+($cid,.pushmode.,$hash($1,32),$gettok(%queue,%q,32))).size > 0) { break }
inc %q
}
; loop was ended with break, start the timer
if (%q <= $numtok(%queue,32)) {
.timer $+ $cid $+ .pushmode. $+ $hash($1,32) 1 $$pushmode.restart pushmode.dump $1
}
}
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS PUSHUSER ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; $1 = +/-mode, $2 = param
alias pushuser {
; remove multiple modes, only use the 1st one given
tokenize 32 $left($1,2) $2
; '$2' is 2 chars long and '$1' starts with '+' or with '-'
if ($len($1) == 2) && ($istok(+ -, $left($1,1),32)) {
; '$2' exists, add the mode to the user queue
if ($2 != $null) { pushmode.queue $+($cid,.user) $1-2 }
; '$2' does not exist, add the mode to the user queue
else { pushmode.queue $+($cid,.user) $1 }
; check if the timer already runs, start the timer
if (!$timer($+($cid,.pushuser))) {
.timer $+ $cid $+ .pushuser 1 $$pushmode.delay pushuser.dump
}
}
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS PUSHUSER.DUMP ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
alias -l pushuser.dump {
; loop as long as there are items in the user queue, set a var with the next item, add the mode to the var
while ($pushmode.queue($+($cid,.user)).size > 0) { var %next = $pushmode.queue($+($cid,.user)).next
var %mode = $+($gettok(%mode,1,32),$gettok(%next,1,32)) $gettok(%mode,2-,32) $gettok(%next,2,32) }
; if '%mode' exists, send the modes
if (%mode) { .quote MODE $me %mode }
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS PUSHMODE.QUEUE ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; pushmode.queue [-eNrw] table mode param
alias -l pushmode.queue {
var %e
; switch is used
if ($left($1,1) == -) {
; got a switch, there are numbers, set a var
if (e isin $1) { if ($right($1,-2) isnum) { var %e = $+(-u,$right($1,-2)) } }
; r switch, w switch, set var
if (r isin $1) { if (w isin $1) { var %x = $hfind($2,$3-4,0,w).data
while (%x) {
; check hash table, delete
if ($gettok($hget($2,$hfind($2,$3-4,%x,w).data),1,32) === $3) || ($3 iswm $gettok($hget($2,$hfind($2,$3-4,%x,w).data),1,32)) {
hdel $2 $hfind($2,$3-4,%x,w).data
}
dec %x
}
}
; no w switch, set vars
else {
var %param = $replace($4,\,\\,|,\|,$chr(40),$+(\,$chr(40)),$chr(41),$+(\,$chr(41)),$chr(91),$+(\,$chr(91)),$chr(93),$+(\,$chr(93)),^,\^,$chr(123),$+(\,$chr(123)),$chr(125),$+(\,$chr(125)),.,\.,$,\$,+,\+,*,\*,?,\?)
var %mode = \ $+ $left($3,1) $+ $chr(91) $+ $replace($left($3,2),\,\\,|,\|,$chr(40),$+(\,$chr(40)),$chr(41),$+(\,$chr(41)),$chr(91),$+(\,$chr(91)),$chr(93),$+(\,$chr(93)),^,\^,$chr(123),$+(\,$chr(123)),$chr(125),$+(\,$chr(125)),.,\.,$,\$,+,\+,*,\*,?,\?) $+ $chr(93)
; check hash table, delete
if ($hfind($2,%mode %param,1,r).data) { hdel $2 $hfind($2,%mode %param,1,r).data }
}
; 1 item left, free hash table
if ($hget($2,0).item == 1) { hfree $2 }
return
}
tokenize 32 $2-4
}
; mode is a usermode, it matches *!*@* and no * or ? are there, and its not for the umode queue
if ($right($2,1) isin $pushmode.prefix) && (*!*@* iswm $3) && (* !isin $3) && (? !isin $3) && (*.user !iswm $1) {
; the user is in the ial, add tag to ialmark, tokenize
if ($ial($gettok($3,1,33))) {
.ialmark $gettok($3,1,33) $ial($gettok($3,1,33)).mark $+($1,.,$iif($hget($1,last),$calc($ifmatch +1),1))
tokenize 32 $1 $2 $+(*!,$gettok($3,2,33))
}
; user is not in ial, tokenize
else { tokenize 32 $1 $2 $gettok($3,1,33) }
}
; set a var, prefix special chars in a regex with a \
var %param = $replace($3,\,\\,|,\|,$chr(40),$+(\,$chr(40)),$chr(41),$+(\,$chr(41)),$chr(91),$+(\,$chr(91)),$chr(93),$+(\,$chr(93)),^,\^,$chr(123),$+(\,$chr(123)),$chr(125),$+(\,$chr(125)),.,\.,$,\$,+,\+,*,\*,?,\?)
var %mode = \ $+ $left($2,1) $+ $chr(91) $+ $replace($left($2,2),\,\\,|,\|,$chr(40),$+(\,$chr(40)),$chr(41),$+(\,$chr(41)),$chr(91),$+(\,$chr(91)),$chr(93),$+(\,$chr(93)),^,\^,$chr(123),$+(\,$chr(123)),$chr(125),$+(\,$chr(125)),.,\.,$,\$,+,\+,*,\*,?,\?) $+ $chr(93)
; there is a 2nd parameter and mode '%mode %param' is not already in the queue, where '%mode' is case sensitive
if ($2 != $null) && ($hfind($1,%mode %param,0,r).data == 0) {
; increase item 'last', add mode '$2-' to the hashtable with item name that 'last' has
hinc -m $1 last | hadd $+(-m,%e) $1 $hget($1,last) $2-
}
; propertie is next and hash table '$1' exists, increase item 'first'
elseif ($isid) && ($prop == next) && ($hget($1)) { hinc -m $1 first
; 'first' is smaller or equal to 'last', set vars
if ($hget($1,first) <= $hget($1,last)) {
var %next = $hget($1,$hget($1,first)), %number = $hget($1,first)
var %mode = $gettok(%next,1,32), %param = $gettok(%next,2,32)
; mode is a usermode, parameter matches *!*@*, set var
if ($right(%mode,1) isin $pushmode.prefix) && (*!*@* iswm %param) {
var %x = $ial(%param,0)
while (%x) { var %nick = $ial(%param,%x).nick
; the tag is there, remove it, set var, stop loop
if ($wildtok($ial(%nick).mark,$+($1,.,%number),1,32)) {
.ialmark %nick $remove($ial(%nick).mark,$ifmatch)
var %next = %mode %nick | break
}
dec %x
}
; no matches found, clear var
if (%x == 0) { var %next = $null }
}
; delete this item from the hashtable
hdel $1 $hget($1,first)
; this is the last item, free the hash table
if ($hget($1,first) >= $hget($1,last)) { hfree $1 }
return %next
}
}
; called as identifier ($alias) and propertie is size ($alias().size)
; decrease number of items with 1, (1 item in queue, and last is there)
elseif ($isid) && ($prop == size) { return $iif($calc($hget($1,0).item -1) >= 0,$ifmatch,0) }
; called as identifier ($alias) and propertie is clear ($alias().clear), free hashtables that match $1
elseif ($isid) && ($prop == clear) { hfree -w $1 }
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS PUSHMODE.TEMPBAN ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
alias -l pushmode.tempban {
var %x = 1
; loop through the channels
while (%x <= $chan(0)) {
; loop as long as a match is found, items with values 0 or lower
while ($hfind($+($cid,.pushmode.,$hash($chan(%x),32),.bans),/^[0-]/,1,r).data) {
; ibl is not filled, or the ban is set, use pushmode to remove the ban
if (!$chan(%x).ibl) || ($hfind($+($cid,.pushmode.,$hash($chan(%x),32),.bans),/^[0-]/,1,r).data isban $chan(%x)) {
pushmode $chan(%x) -b $hfind($+($cid,.pushmode.,$hash($chan(%x),32),.bans),/^[0-]/,1,r).data
}
; del the item from the hash table
hdel $+($cid,.pushmode.,$hash($chan(%x),32),.bans) $hfind($+($cid,.pushmode.,$hash($chan(%x),32),.bans),/^[0-]/,1,r).data
}
; check if hash table is empty and the hash table exists, remove hash table
if ($hget($+($cid,.pushmode.,$hash($chan(%x),32),.bans),0).item == 0) && ($hget($+($cid,.pushmode.,$hash($chan(%x),32),.bans))) {
hfree $+($cid,.pushmode.,$hash($chan(%x),32),.bans)
}
inc %x
}
; start the timer
.timer $+ $cid $+ .pushmode.bans 1 $$pushmode.ban pushmode.tempban
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; DISCONNECT EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
on *:disconnect: { pushmode -c }
