Difference between revisions of "Test2"

From Scriptwiki
Jump to: navigation, search
m
m
Line 1: Line 1:
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; AUTH_UPDATE ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
;
 
;  by Vliedel -- #vliedel @ QuakeNet
 
;  version 1.1  (written and tested on mIRC 6.2)
 
;  made for networks supporting WHOX
 
;
 
;
 
;What does this script do?
 
;
 
;  - updates the auths of nicks and stores them in a hash table
 
;  - if a channel is too big, /who nick1,nick2,nick3 etc is done untill the auths for the channel is updated
 
;  - users who have a site with the auth in it will be saved without a /who
 
;    ie: "Vliedel" in "Vliedel.users.quakenet.org" will be treated as auth on the QuakeNet network
 
;  - users who are not authed (auth 0) will be checked every x time to see if they are authed yet
 
;  - script updates from largest to the smallest channel
 
;
 
;
 
;How to use this script?
 
;
 
;  - config the options below
 
;  - /load -rs auth_update.mrc to load the script
 
;  - script starts on load or on connect
 
;  - to get a nicks auth use: $auth(nick) or $auth(nick,cid)
 
;  - /authupdate.next <nick> [nick] [nick] ... can be used to get auths of those nicks as soon as possible
 
;    please note that this will use a bit less efficient way to get the auths.
 
;    You can use the following script to see when such a requested nick is updated
 
;      on *:SIGNAL:authupdate:{
 
;        if ($2 == $null) { echo -a Requested: $1 is not on a common channel }
 
;        elseif ($2 == 0) { echo -a Requested: $1 is not authed }
 
;        else { echo -a Requested: $1 is authed as $2 }
 
;      }
 
;
 
;    Note that this signal returns $2 == $null when someone isn't on a common channel.
 
;    This may occur for example when someone parted a channel between the /who and the who reply.
 
;
 
;  - /authupdate can be used to make the script update the auths without waiting for the timer to trigger it
 
;  - You can use the following script to see when a nick is updated
 
;      on *:SIGNAL:authupdate.new:{
 
;        if ($2 == 0) { echo -a $1 is not authed }
 
;        else { echo -a $1 is authed as $2 }
 
;      }
 
;
 
;
 
;
 
;Why is this script good?
 
;
 
;  - sending /who chan for every channel is not needed and goes slow (lag)
 
;  - sending /who chan on join may cause Excess Flood or Max sendQ exceeded
 
;  - sending /who chan1,chan2,chan3 can be much faster, but only if there are not too many results (Max sendQ exceeded)
 
;  - unauthed users can auth without you knowing, so you need to check if they're authed every so many time.
 
;
 
;
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; SETTINGS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
[[alias]] -l max.who {
 
  ; maximum number of replies in a WHO, too high may cause 'Max sendQ exceeded' disconnection
 
  ; too low may take the script a long time to update the auths, 1000 should be fine for most situations
 
  [[return]] 1000
 
}
 
 
[[alias]] -l len.who {
 
  ; maximum length of the /who <string>, too long may cause the server to ignore the command
 
  ; too low may slow things down, 400 should be fine in most cases
 
  [[return]] 400
 
}
 
 
[[alias]] -l delay.who {
 
  ; N seconds after your first join, the script starts to update the auths
 
  [[return]] 10
 
}
 
 
[[alias]] -l repeat.who {
 
  ; wait N seconds after doing /who to do the next check and /who
 
  [[return]] 20
 
}
 
 
[[alias]] -l minnicks.who {
 
  ; minimum nr of nicks with unknown auth in a channel to do /who #channel rather then /who nick,nick,
 
  [[return]] 3
 
}
 
 
[[alias]] -l minratio.who {
 
  ; minimum ratio of (nicks with unknown auth) / (total nicks) in a channel to do /who #channel rather then /who nick,nick,
 
  [[return]] 0.04
 
}
 
 
[[alias]] -l queue.repeat.who {
 
  ; number of seconds to do the next /who to check if someone who wasn't authed is now authed
 
  [[return]] 600
 
}
 
 
[[alias]] -l next.wait {
 
  ; wait N seconds to do the next /who check triggered by authupdate.next after the last /who
 
  [[return]] 10
 
}
 
 
[[alias]] -l used.network {
 
  ; The networks the script is supposed to work on (case sensitive).
 
  ; NOTE that the script ONLY works on networks supporting WHOX (ircu 2.10.* should work)
 
  ; $1 is the network
 
  [[return]] $istokcs(QuakeNet UnderNet GameSurge HanIRC NetGamers OGameNet,$1,32)
 
}
 
 
[[alias]] -l auth.site {
 
  ; For every network a check to see if a user has a site where his authname is in
 
  ; $1 is the network, $2 is the site
 
  [[If-Then-Else|if]] ($1 === QuakeNet) { [[return]] $iif(*.users.quakenet.org iswm $2,$true) }
 
  [[If-Then-Else|elseif]] ($1 === UnderNet) { [[return]] $iif(*.users.undernet.org iswm $2,$true) }
 
  [[If-Then-Else|elseif]] ($1 === GameSurge) { [[return]] $iif(*.*.GameSurge iswm $2,$true) }
 
  [[If-Then-Else|elseif]] ($1 === HanIRC) { [[return]] $iif(*.users.HanIRC.org iswm $2,$true) }
 
  [[If-Then-Else|elseif]] ($1 === NetGamers) { [[return]] $iif(*.users.netgamers.org iswm $2,$true) }
 
  [[If-Then-Else|elseif]] ($1 === OGameNet) { [[return]] $iif(*.user.OGameNet iswm $2,$true) }
 
}
 
 
[[alias]] -l auth.from.site {
 
  ; For every network the method to return the auth from the site
 
  ; $1 is the network, $2 is the site
 
  [[If-Then-Else|if]] ($1 === QuakeNet) { [[return]] $gettok($2,1,46) }
 
  [[If-Then-Else|elseif]] ($1 === UnderNet) { [[return]] $gettok($2,1,46) }
 
  [[If-Then-Else|elseif]] ($1 === GameSurge) { [[return]] $gettok($2,1,46) }
 
  [[If-Then-Else|elseif]] ($1 === HanIRC) { [[return]] $gettok($2,1,46) }
 
  [[If-Then-Else|elseif]] ($1 === NetGamers) { [[return]] $gettok($2,1,46) }
 
  [[If-Then-Else|elseif]] ($1 === OGameNet) { [[return]] $gettok($2,1,46) }
 
}
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
[[alias]] auth {
 
  [[If-Then-Else|if]] (!$isid) { $iif($show,.auth,auth) $1- | [[return]] }
 
  [[If-Then-Else|if]] ($1 == $null) || (($2 !== $null) && ((!$scid($2)) || (!$2))) { [[return]] }
 
  [[return]] $hget(auths. $+ $iif($2 !== $null,$2,$cid),$1)
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTHUPDATE ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
[[alias]] authupdate { [[echo]] -a Auth update: $auth_update.update }
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTHUPDATE.NEXT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
[[alias]] authupdate.next {
 
  [[Local_Variables|var]] %i = $0
 
  [[while]] (%i) {
 
    [[Local_Variables|var]] %n = $gettok($1-,%i,32)
 
    [[If-Then-Else|if]] (!$comchan(%n,1)) { .[[signal]] authupdate %n }
 
    [[If-Then-Else|else]] { auth.n.add %n }
 
    [[dec]] %i
 
  }
 
  [[If-Then-Else|if]] (!$timer($cid $+ .auth_update.update)) { auth_update.update n }
 
  [[If-Then-Else|else]] {
 
    [[Local_Variables|var]] %d = $timer($cid $+ .auth_update.update).delay , %l = $timer($cid $+ .auth_update.update).secs
 
    .[[timer]] $+ $cid $+ .auth_update.update 1 $iif($calc(%d - %l) < $next.wait,$calc($v2 - $v1),0) auth_update.update n
 
  }
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; LOAD EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
on *:LOAD:{ scon -at1 auth_load }
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH_LOAD ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
[[alias]] -l auth_load {
 
  .[[timer]] $+ $cid $+ .auth_update.update 1 $delay.who auth_update.update
 
  [[If-Then-Else|if]] ($hget(auths. $+ $cid)) { [[hfree]] $v1 }
 
  [[If-Then-Else|if]] ($hget(auths.l. $+ $cid)) { [[hfree]] $v1 }
 
  [[If-Then-Else|if]] ($hget(auths.q. $+ $cid)) { [[hfree]] $v1 }
 
  [[If-Then-Else|if]] ($hget(auths.n. $+ $cid)) { [[hfree]] $v1 }
 
  [[If-Then-Else|if]] ($hget(auths.u. $+ $cid)) { [[hfree]] $v1 }
 
  [[hmake]] auths. $+ $cid 200
 
  [[hmake]] auths.l. $+ $cid 200
 
  [[hmake]] auths.q. $+ $cid 200
 
  [[hmake]] auths.n. $+ $cid 100
 
  [[Local_Variables|var]] %i = $comchan($me,0)
 
  [[while]] (%i) {
 
    [[Local_Variables|var]] %chan = $comchan($me,%i)
 
    [[Local_Variables|var]] %j = $nick(%chan,0)
 
    [[while]] (%j) {
 
      auth.l.add.wid $chan(%chan).wid $nick(%chan,%j)
 
      [[dec]] %j
 
    }
 
    [[dec]] %i
 
  }
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH_UPDATE.UPDATE ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
[[alias]] -l auth_update.update {
 
  [[Local_Variables|var]] %who
 
  [[If-Then-Else|if]] (!$hget(auths.u. $+ $cid)) {
 
    .[[timer]] $+ $cid $+ .auth_update.update off
 
    [[hmake]] auths.u. $+ $cid 200
 
    [[Local_Variables|var]] %who = $auth_update.who
 
    [[If-Then-Else|if]] (%who) {
 
      [[hadd]] auths.u. $+ $cid -mask %who $+ ,,, $+ 273
 
      .[[timer]] $+ $cid $+ .auth_update.timeout 1 $calc($repeat.who * 2) auth_update.timeout
 
      .quote WHO $hget(auths.u. $+ $cid,-mask) % $+ nat,273
 
    }
 
    [[If-Then-Else|else]] {
 
      [[hfree]] auths.u. $+ $cid
 
      .[[timer]] $+ $cid $+ .auth_update.update 1 $$repeat.who auth_update.update
 
    }
 
  }
 
  [[If-Then-Else|if]] (%who) { [[return]] updating }
 
  [[If-Then-Else|elseif]] ($hget(auths.u. $+ $cid)) { [[return]] already in progress }
 
  [[If-Then-Else|else]] { [[return]] nothing to update }
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH_UPDATE.TIMEOUT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
[[alias]] -l auth_update.timeout {
 
  [[hfree]] auths.u. $+ $cid
 
  auth_update.update
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH_UPDATE.SORT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; sorts channels by number of nicks in channel
 
; <number of nicks>.<channel number>
 
; returns 127.1 23.2 <= means 127 nicks on comchan 1
 
[[alias]] -l auth_update.sort {
 
  [[Local_Variables|var]] %i = $comchan($me,0) , %chans
 
  [[while]] (%i) {
 
    [[Local_Variables|var]] %chans = %chans $nick($comchan($me,%i),0) $+ . $+ %i
 
    [[dec]] %i
 
  }
 
  [[return]] $sorttok(%chans,32,n)
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH_UPDATE.WHO ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; $auth_update.who(N,L)
 
; returns #chan,#chan,nick,nick
 
[[alias]] -l auth_update.who {
 
  [[Local_Variables|var]] %t = auths.u. $+ $cid , %t.l = auths.l. $+ $cid , %t.q = auths.q. $+ $cid , %t.n = auths.n. $+ $cid
 
  [[Local_Variables|var]] %n.max = $max.who , %l.max = $len.who , %n.min = $minnicks.who , %ratio = $minratio.who
 
  [[Local_Variables|var]] %len , %n.nr , %chans , %nicks , %chans.go
 
  [[If-Then-Else|if]] $hget(auths.n.temp) { [[hfree]] auths.n.temp }
 
  [[hmake]] auths.n.temp
 
  [[Local_Variables|var]] %n = $hget(%t.n,-firstnick)
 
  [[while]] (%n) {
 
    [[inc]] %len $calc($len(%n) + 1)
 
    [[inc]] %n.nr
 
    [[If-Then-Else|if]] (%n.nr > %n.max) || (%len > %l.max) { [[dec]] %n.nr | [[dec]] %len $calc($len(%n) + 1) | [[break]] }
 
    [[hadd]] auths.n.temp %n 1
 
    [[hadd]] %t %n 1
 
    [[Local_Variables|var]] %nicks = $addtok(%nicks,%n,44) , %n = $gettok($hget(%t.n,%n),2,32)
 
  }
 
 
 
  [[Local_Variables|var]] %sorted = $auth_update.sort , %i = $numtok(%sorted,32) , %time = $calc($ctime - $queue.repeat.who)
 
  [[while]] (%i) {
 
    [[Local_Variables|var]] %comchan = $gettok($gettok(%sorted,%i,32),2,46) , %chan = $comchan($me,%comchan) , %id = $chan(%chan).wid $+ .
 
    [[Local_Variables|var]] %n.c = $nick(%chan,0) , %left , %go
 
    [[If-Then-Else|if]] (%n.c > %n.max) { [[break]] }
 
    [[If-Then-Else|if]] $hget(auths.temp) { [[hfree]] auths.temp }
 
    [[hmake]] auths.temp
 
    [[Local_Variables|var]] %n = $hget(%t.n,%id $+ -firstnick)
 
    [[while]] (%n) {
 
      [[If-Then-Else|if]] (!$hget(%t,%n)) || ($hget(auths.n.temp,%n)) { [[hadd]] auths.temp %n 1 | [[inc]] %left }
 
      [[If-Then-Else|if]] (((%left >= %n.min) && ($calc(%left / %n.c) >= %ratio)) || (%left == %n.c)) { [[Local_Variables|var]] %go = 1 | [[break]] }
 
      [[Local_Variables|var]] %n = $gettok($hget(%t.n,%id $+ %n),2,32)
 
    }
 
    [[Local_Variables|var]] %n = $hget(%t.l,%id $+ -firstnick)
 
    [[while]] (%n) {
 
      [[If-Then-Else|if]] (!$hget(%t,%n)) && (!$hget(auths.temp,%n)) { [[inc]] %left }
 
      [[If-Then-Else|if]] (((%left >= %n.min) && ($calc(%left / %n.c) >= %ratio)) || (%left == %n.c)) { [[Local_Variables|var]] %go = 1 | [[break]] }
 
      [[Local_Variables|var]] %n = $gettok($hget(%t.l,%id $+ %n),2,32)
 
    }
 
    [[Local_Variables|var]] %n = $hget(%t.q,%id $+ -firstnick)
 
    [[while]] (%n) {
 
      [[tokenize]] 32 $hget(%t.q,%id $+ %n)
 
      [[If-Then-Else|if]] ($1 > %time) { [[break]] }
 
      [[If-Then-Else|if]] (!$hget(%t,%n)) && (!$hget(auths.temp,%n)) { [[inc]] %left }
 
      [[If-Then-Else|if]] (((%left >= %n.min) && ($calc(%left / %n.c) >= %ratio)) || (%left == %n.c)) { [[Local_Variables|var]] %go = 1 | [[break]] }
 
      [[Local_Variables|var]] %n = $3
 
    }
 
    [[If-Then-Else|if]] (!%go) { [[dec]] %i | [[continue]] }
 
    [[Local_Variables|var]] %j = %n.c , %n.tmp = %n.nr , %l.tmp = %len , %chans.go = %chans.go %comchan
 
    [[inc]] %l.tmp $calc($len(%chan) + 1)
 
    [[while]] (%j) {
 
      [[Local_Variables|var]] %n = $nick(%chan,%j)
 
      [[If-Then-Else|if]] (!$hget(%t,%n)) { [[inc]] %n.tmp }
 
      [[If-Then-Else|if]] ($hget(auths.n.temp,%n)) { [[dec]] %l.tmp $calc($len(%n) + 1) }
 
      [[dec]] %j
 
    }
 
    [[If-Then-Else|if]] (%l.tmp > %l.max) || (%n.tmp > %n.max) { [[dec]] %i | [[continue]] }
 
    [[Local_Variables|var]] %j = $nick(%chan,0)
 
    [[while]] (%j) {
 
      [[Local_Variables|var]] %n = $nick(%chan,%j)
 
      [[hadd]] %t %n 1
 
      [[hdel]] auths.n.temp %n
 
      [[Local_Variables|var]] %nicks = $remtok(%nicks,%n,1,44)
 
      [[dec]] %j
 
    }
 
    [[Local_Variables|var]] %len = %l.tmp , %n.nr = %n.tmp , %chans = $addtok(%chans,%chan,44)
 
    [[dec]] %i
 
  }
 
 
 
  [[Local_Variables|var]] %i = $comchan($me,0)
 
  [[while]] (%i) {
 
    [[Local_Variables|var]] %chan = $comchan($me,%i)
 
    [[If-Then-Else|if]] (($nick(%chan,0) > %n.max) || (!$istok(%chans.go,%i,32))) {
 
      [[Local_Variables|var]] %id = $chan(%chan).wid $+ . , %n = $hget(%t.l,%id $+ -firstnick)
 
      [[while]] (%n) {
 
        [[If-Then-Else|if]] (!$hget(%t,%n)) {
 
          [[inc]] %len $calc($len(%n) + 1)
 
          [[inc]] %n.nr
 
          [[If-Then-Else|if]] (%n.nr > %n.max) || (%len > %l.max) { [[break]] }
 
          [[hadd]] %t %n 1
 
          [[Local_Variables|var]] %nicks = $addtok(%nicks,%n,44)
 
        }
 
        [[Local_Variables|var]] %n = $gettok($hget(%t.l,%id $+ %n),2,32)
 
      }
 
      [[If-Then-Else|if]] (%n.nr > %n.max) || (%len > %l.max) { [[break]] }
 
      [[Local_Variables|var]] %n = $hget(%t.q,%id $+ -firstnick)
 
      [[while]] (%n) {
 
        [[tokenize]] 32 $hget(%t.q,%id $+ %n)
 
        [[If-Then-Else|if]] ($1 > %time) { [[break]] }
 
        [[If-Then-Else|if]] (!$hget(%t,%n)) {
 
          [[inc]] %len $calc($len(%n) + 1)
 
          [[inc]] %n.nr
 
          [[If-Then-Else|if]] (%n.nr > %n.max) || (%len > %l.max) { [[break]] }
 
          [[hadd]] %t %n 1
 
          [[Local_Variables|var]] %nicks = $addtok(%nicks,%n,44)
 
        }
 
        [[Local_Variables|var]] %n = $3
 
      }
 
    }
 
    [[If-Then-Else|if]] (%n.nr > %n.max) || (%len > %l.max) { [[break]] }
 
    [[dec]] %i
 
  }
 
  [[If-Then-Else|if]] $hget(auths.temp) { [[hfree]] auths.temp }
 
  [[If-Then-Else|if]] $hget(auths.n.temp) { [[hfree]] auths.n.temp }
 
  [[return]] $addtok(%chans,%nicks,44)
 
}
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; RAW 354 SPECIAL WHO REPLY ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; 354 <you>  <nr>  <nick>  <auth>
 
; 354 Vliedel 273  L      0
 
RAW 354:& 273 & &:{
 
  [[If-Then-Else|if]] ($comchan($3,1)) { auth_update.nick $3 $4 }
 
  [[If-Then-Else|elseif]] ($hget(auths.n. $+ $cid,$3)) { auth.n.rem $3 | .[[signal]] authupdate $3 }
 
  [[haltdef]]
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; RAW 315 WHO END ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; 315 <you>    <requested>              :End of /who list.
 
; 315 Vliedel  #vliedel,Rutix,fishbot  :End of /WHO list.
 
RAW 315:& & end of /WHO list.: {
 
  [[If-Then-Else|if]] ($hget(auths.u. $+ $cid,-mask) == $2) {
 
    [[hfree]] auths.u. $+ $cid
 
    .[[timer]] $+ $cid $+ .auth_update.timeout off
 
    .[[timer]] $+ $cid $+ .auth_update.update 1 $iif($hget(auths.n. $+ $cid,1).item,$next.wait,$repeat.who) auth_update.update
 
    [[haltdef]]
 
  }
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH_UPDATE.NICK ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; $1 = nick    $2 = auth
 
[[alias]] -l auth_update.nick {
 
  [[If-Then-Else|if]] ($hget(auths. $+ $cid,$1) != $2) {
 
    .[[signal]] authupdate.new $1 $2
 
    auth.add $1 $2
 
  }
 
  auth.l.rem $1
 
  [[If-Then-Else|if]] ($2 == 0) { auth.q.add $1 }
 
  [[If-Then-Else|else]] { auth.q.rem $1 }
 
  [[If-Then-Else|if]] ($hget(auths.n. $+ $cid,$1)) { auth.n.rem $1 | .[[signal]] authupdate $1 $2 }
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; JOIN EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
on *:JOIN:#:{
 
  [[If-Then-Else|if]] ($nick == $me) && ($used.network($network)) {
 
    [[If-Then-Else|if]] (!$hget(auths. $+ $cid)) { [[hmake]] auths. $+ $cid 200 }
 
    [[If-Then-Else|if]] (!$hget(auths.l. $+ $cid)) { [[hmake]] auths.l. $+ $cid 200 }
 
    [[If-Then-Else|if]] (!$hget(auths.q. $+ $cid)) { [[hmake]] auths.q. $+ $cid 200 }
 
    [[If-Then-Else|if]] (!$hget(auths.n. $+ $cid)) { [[hmake]] auths.n. $+ $cid 100 }
 
    [[If-Then-Else|if]] (!$timer($cid $+ .auth_update.update)) { .[[timer]] $+ $cid $+ .auth_update.update 1 $delay.who auth_update.update }
 
    [[return]]
 
  }
 
  [[If-Then-Else|if]] ($auth.site($network,$site)) { auth_update.nick $nick $auth.from.site($network,$site) | [[return]] }
 
  [[If-Then-Else|if]] ($hget(auths. $+ $cid,$nick) == $null) { auth.l.add.wid $chan($chan).wid $nick }
 
  [[If-Then-Else|elseif]] ($hget(auths. $+ $cid,$nick) == 0) {
 
    auth.q.add.wid $chan($chan).wid $nick
 
    [[If-Then-Else|if]] (!$comchan($nick,2)) { auth.q.add.main $nick }
 
  }
 
  [[If-Then-Else|if]] ($hget(auths.n. $+ $cid,$nick)) { auth.n.add.wid $chan($2).wid $nick }
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; RAW 366 - END OF NAMES LIST ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; 366 Vliedel #vliedel :End of /NAMES list.
 
366 Vliedel #Help :End of /NAMES list
 
RAW 366:& & end of /names list.:{
 
  [[Local_Variables|var]] %i = $nick($2,0) , %t = auths. $+ $cid
 
  [[while]] (%i) {
 
    [[Local_Variables|var]] %n = $nick($2,%i)
 
    [[If-Then-Else|if]] ($hget(%t,%n) == $null) { auth.l.add.wid $chan($2).wid %n }
 
    [[If-Then-Else|elseif]] ($hget(%t,%n) == 0) {
 
      auth.q.add.wid $chan($2).wid %n
 
      [[If-Then-Else|if]] (!$comchan(%n,2)) { auth.q.add.main %n }
 
    }
 
    [[If-Then-Else|if]] ($hget(auths.n. $+ $cid,%n)) { auth.n.add.wid $chan($2).wid %n }
 
    [[dec]] %i
 
  }
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; PART EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
on *:PART:#:{
 
  [[If-Then-Else|if]] ($nick == $me) {
 
    auth.rem.chan $chan
 
    auth.l.rem.chan.all $chan
 
    auth.q.rem.chan.all $chan
 
    auth.n.rem.chan.all $chan
 
  }
 
  [[If-Then-Else|else]] {
 
    auth.l.rem.wid $chan($chan).wid $nick
 
    auth.q.rem.wid $chan($chan).wid $nick
 
    auth.n.rem.wid $chan($chan).wid $nick
 
    [[If-Then-Else|if]] (!$comchan($nick,2)) {
 
      auth.rem $nick
 
      auth.q.rem.main $nick
 
      auth.n.rem.main $nick
 
    }
 
    [[If-Then-Else|elseif]] ($auth.site($network,$site)) { auth_update.nick $nick $auth.from.site($network,$site) }
 
  }
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; KICK EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
on *:KICK:#:{
 
  [[If-Then-Else|if]] ($knick == $me) {
 
    auth.rem.chan $chan
 
    auth.l.rem.chan.all $chan
 
    auth.q.rem.chan.all $chan
 
    auth.n.rem.chan.all $chan
 
  }
 
  [[If-Then-Else|else]] {
 
    auth.l.rem.wid $chan($chan).wid $knick
 
    auth.q.rem.wid $chan($chan).wid $knick
 
    auth.n.rem.wid $chan($chan).wid $knick
 
    [[If-Then-Else|if]] (!$comchan($knick,2)) {
 
      auth.rem $knick
 
      auth.q.rem.main $knick
 
      auth.n.rem.main $knick
 
    }
 
    [[If-Then-Else|if]] ($auth.site($network,$site)) && ($comchan($nick,1)) { auth_update.nick $nick $auth.from.site($network,$site) }
 
  }
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; QUIT EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
on *:QUIT:{
 
  auth.rem $nick
 
  auth.l.rem $nick
 
  auth.q.rem $nick
 
  auth.n.rem $nick
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; NICK EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
on *:NICK:{
 
  auth.nick $nick $newnick
 
  auth.l.nick $nick $newnick
 
  auth.q.nick $nick $newnick
 
  auth.n.nick $nick $newnick
 
  [[If-Then-Else|if]] ($auth.site($network,$site)) { auth_update.nick $newnick $auth.from.site($network,$site) }
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; IAL-UPDATING EVENTS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
on *:TEXT:*:*:{ [[If-Then-Else|if]] ($auth.site($network,$site)) && ($comchan($nick,1)) { auth_update.nick $nick $auth.from.site($network,$site) } }
 
on *:ACTION:*:*:{ [[If-Then-Else|if]] ($auth.site($network,$site)) && ($comchan($nick,1)) { auth_update.nick $nick $auth.from.site($network,$site) } }
 
on *:NOTICE:*:*:{ [[If-Then-Else|if]] ($auth.site($network,$site)) && ($comchan($nick,1)) { auth_update.nick $nick $auth.from.site($network,$site) } }
 
on *:RAWMODE:#:{ [[If-Then-Else|if]] ($auth.site($network,$site)) && ($comchan($nick,1)) { auth_update.nick $nick $auth.from.site($network,$site) } }
 
on *:TOPIC:#:{ [[If-Then-Else|if]] ($auth.site($network,$site)) && ($comchan($nick,1)) { auth_update.nick $nick $auth.from.site($network,$site) } }
 
on *:INVITE:#:{ [[If-Then-Else|if]] ($auth.site($network,$site)) && ($comchan($nick,1)) { auth_update.nick $nick $auth.from.site($network,$site) } }
 
[[CTCP]] *:*:*:{ [[If-Then-Else|if]] ($auth.site($network,$site)) && ($comchan($nick,1)) { auth_update.nick $nick $auth.from.site($network,$site) } }
 
RAW 352:& & & & & & & & *: { [[If-Then-Else|if]] ($auth.site($network,$4)) && ($comchan($6,1)) { auth_update.nick $6 $auth.from.site($network,$4) } }
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; DISCONNECT EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
on *:DISCONNECT:{
 
  [[If-Then-Else|if]] ($hget(auths.u $+ $cid)) { [[hfree]] $v1 }
 
  [[If-Then-Else|if]] ($hget(auths. $+ $cid)) { [[hfree]] $v1 }
 
  [[If-Then-Else|if]] ($hget(auths.q. $+ $cid)) { [[hfree]] $v1 }
 
  [[If-Then-Else|if]] ($hget(auths.l. $+ $cid)) { [[hfree]] $v1 }
 
  [[If-Then-Else|if]] ($hget(auths.n. $+ $cid)) { [[hfree]] $v1 }
 
}
 
 
 
; 200
 
; auths.cid  nick --> auth
 
 
; 200
 
; auths.l.cid  chanwid.nick --> lnick rnick
 
; auths.l.cid  chanwid.-firstnick --> first_nick_in_list
 
; auths.l.cid  chanwid.-lastnick --> last_nick_in_list
 
 
; 200
 
; auths.q.cid  chanwid.nick --> ctime lnick rnick
 
; auths.q.cid  chanwid.-firstnick --> first_nick_in_queue
 
; auths.q.cid  chanwid.-lastnick --> last_nick_in_queue
 
; auths.q.cid  nick --> ctime
 
 
; 100
 
; auths.n.cid  chanwid.nick --> lnick rnick
 
; auths.n.cid  chanwid.-firstnick --> first_nick_in_list
 
; auths.n.cid  chanwid.-lastnick --> last_nick_in_list
 
; auths.n.cid  nick --> lnick rnick
 
; auths.n.cid  -firstnick --> first_nick_in_list
 
; auths.n.cid  -lastnick --> last_nick_in_list
 
 
 
 
; ---------------------------------------------------------------------------------------------
 
; --------------------------------------- AUTHS - TABLE ---------------------------------------
 
; ---------------------------------------------------------------------------------------------
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.ADD ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; $1 = nick  $2 = auth
 
[[alias]] -l auth.add {
 
  [[If-Then-Else|if]] (!$hget(auths. $+ $cid)) { [[return]] }
 
  [[hadd]] auths. $+ $cid $1 $2
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.REM ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; $1 = nick
 
[[alias]] -l auth.rem {
 
  [[If-Then-Else|if]] (!$hget(auths. $+ $cid)) { [[return]] }
 
  [[hdel]] auths. $+ $cid $1
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.REM.CHAN ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; $1 = chan
 
[[alias]] -l auth.rem.chan {
 
  [[If-Then-Else|if]] (!$hget(auths. $+ $cid)) { [[return]] }
 
  [[Local_Variables|var]] %i = $nick($1,0)
 
  [[while]] (%i) {
 
    [[If-Then-Else|if]] (!$comchan($nick($1,%i),2)) { [[hdel]] auths. $+ $cid $nick($1,%i) }
 
    [[dec]] %i
 
  }
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.NICK ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; $1 = nick  $2 = newnick
 
[[alias]] -l auth.nick {
 
  [[If-Then-Else|if]] ($hget(auths. $+ $cid,$1) !== $null) { [[hdel]] auths. $+ $cid $1 | [[hadd]] auths. $+ $cid $2 $v1 }
 
}
 
 
 
 
; ----------------------------------------------------------------------------------------------------
 
; --------------------------------------- AUTHS - LEFT - TABLE ---------------------------------------
 
; ----------------------------------------------------------------------------------------------------
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.L.ADD.WID ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; $1 = wid  $2 = nick
 
[[alias]] -l auth.l.add.wid {
 
  [[Local_Variables|var]] %table = auths.l. $+ $cid
 
  [[If-Then-Else|if]] (!$hget(%table)) { [[return]] }
 
  [[Local_Variables|var]] %id = $1 $+ . ,  %lastnick = $hget(%table,%id $+ -lastnick)
 
  [[If-Then-Else|if]] ($hget(%table,%id $+ $2)) { [[return]] }
 
  [[If-Then-Else|if]] (%lastnick) {
 
    [[hadd]] %table %id $+ $2 %lastnick 0
 
    [[hadd]] %table %id $+ %lastnick $gettok($hget(%table,%id $+ %lastnick),1,32) $2
 
  }
 
  [[If-Then-Else|else]] {
 
    [[hadd]] %table %id $+ $2 0 0
 
    [[hadd]] %table %id $+ -firstnick $2
 
  }
 
  [[hadd]] %table %id $+ -lastnick $2
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.L.REM ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; $1 = nick
 
[[alias]] -l auth.l.rem {
 
  [[If-Then-Else|if]] (!$hget(auths.l. $+ $cid)) { [[return]] }
 
  [[Local_Variables|var]] %i = $comchan($1,0)
 
  [[while]] (%i) {
 
    auth.l.rem.wid $chan($comchan($1,%i)).wid $1
 
    [[dec]] %i
 
  }
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.L.REM.WID ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; $1 = wid  $2 = nick
 
[[alias]] -l auth.l.rem.wid {
 
  [[Local_Variables|var]] %table = auths.l. $+ $cid
 
  [[If-Then-Else|if]] (!$hget(%table)) { [[return]] }
 
  [[Local_Variables|var]] %id = $1 $+ . , %val = $hget(%table,%id $+ $2)
 
  [[If-Then-Else|if]] (!%val) { [[return]] }
 
  [[Local_Variables|var]] %nick.l = $gettok(%val,1,32) , %nick.r = $gettok(%val,2,32)
 
  [[hdel]] %table %id $+ $2
 
  [[If-Then-Else|if]] (%nick.l == 0) && (%nick.r == 0) { [[hdel]] %table %id $+ -lastnick | [[hdel]] %table %id $+ -firstnick | [[return]] }
 
  [[If-Then-Else|if]] (%nick.l !== 0) { [[hadd]] %table %id $+ %nick.l $gettok($hget(%table,%id $+ %nick.l),1,32) %nick.r }
 
  [[If-Then-Else|else]] { [[hadd]] %table %id $+ -firstnick %nick.r }
 
  [[If-Then-Else|if]] (%nick.r !== 0) { [[hadd]] %table %id $+ %nick.r %nick.l $gettok($hget(%table,%id $+ %nick.r),2,32) }
 
  [[If-Then-Else|else]] { [[hadd]] %table %id $+ -lastnick %nick.l }
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.L.REM.CHAN.ALL ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; $1 = chan
 
[[alias]] -l auth.l.rem.chan.all {
 
  [[If-Then-Else|if]] (!$hget(auths.l. $+ $cid)) { [[return]] }
 
  [[hdel]] -w auths.l. $+ $cid $chan($1).wid $+ .*
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.L.NICK ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; $1 = nick  $2 = newnick
 
[[alias]] -l auth.l.nick {
 
  [[If-Then-Else|if]] ($1 == $2) { [[return]] }
 
  [[Local_Variables|var]] %table = auths.l. $+ $cid
 
  [[If-Then-Else|if]] (!$hget(%table)) { [[return]] }
 
  [[Local_Variables|var]] %i = $comchan($2,0)
 
  [[while]] (%i) {
 
    [[Local_Variables|var]] %id = $chan($comchan($2,%i)).wid $+ . , %val = $hget(%table,%id $+ $1)
 
    [[If-Then-Else|if]] (%val) {
 
      [[hdel]] %table %id $+ $1
 
      [[hadd]] %table %id $+ $2 %val
 
      [[Local_Variables|var]] %nick.l = $gettok(%val,1,32) , %nick.r = $gettok(%val,2,32)
 
      [[If-Then-Else|if]] (%nick.l !== 0) { [[hadd]] %table %id $+ %nick.l $gettok($hget(%table,%id $+ %nick.l),1,32) $2 }
 
      [[If-Then-Else|else]] { [[hadd]] %table %id $+ -firstnick $2 }
 
      [[If-Then-Else|if]] (%nick.r !== 0) { [[hadd]] %table %id $+ %nick.r $2 $gettok($hget(%table,%id $+ %nick.r),2,32) }
 
      [[If-Then-Else|else]] { [[hadd]] %table %id $+ -lastnick $2 }
 
    }
 
    [[dec]] %i
 
  }
 
}
 
 
 
 
; -----------------------------------------------------------------------------------------------------
 
; --------------------------------------- AUTHS - QUEUE - TABLE ---------------------------------------
 
; -----------------------------------------------------------------------------------------------------
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.Q.ADD ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; $1 = nick
 
[[alias]] -l auth.q.add {
 
  [[If-Then-Else|if]] (!$hget(auths.q. $+ $cid)) { [[return]] }
 
  auth.q.add.main $1
 
  [[Local_Variables|var]] %i = $comchan($1,0)
 
  [[while]] (%i) {
 
    auth.q.add.wid $chan($comchan($1,%i)).wid $1
 
    [[dec]] %i
 
  }
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.Q.ADD.WID ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; $1 = wid  $2 = nick
 
[[alias]] -l auth.q.add.wid {
 
  [[Local_Variables|var]] %table = auths.q. $+ $cid
 
  [[If-Then-Else|if]] (!$hget(%table)) { [[return]] }
 
  [[Local_Variables|var]] %id = $1 $+ . , %ctime = $iif($hget(%table,$2) == $null,$ctime,$v1)
 
  auth.q.rem.wid $1 $2
 
  [[Local_Variables|var]] %lastnick = $hget(%table,%id $+ -lastnick)
 
  [[If-Then-Else|if]] (!%lastnick) {
 
    [[hadd]] %table %id $+ $2 %ctime 0 0
 
    [[hadd]] %table %id $+ -firstnick $2
 
    [[hadd]] %table %id $+ -lastnick $2
 
    [[return]]
 
  }
 
  [[If-Then-Else|if]] (%ctime >= $hget(%table,%lastnick)) {
 
    [[hadd]] %table %id $+ $2 %ctime %lastnick 0
 
    [[hadd]] %table %id $+ %lastnick $gettok($hget(%table,%id $+ %lastnick),1-2,32) $2
 
    [[hadd]] %table %id $+ -lastnick $2
 
    [[return]]
 
  }
 
  [[Local_Variables|var]] %n = $hget(%table,%id $+ -firstnick) , %nick = $2
 
  [[while]] (%n) {
 
    [[tokenize]] 32 $hget(%table,%id $+ %n)
 
    [[If-Then-Else|if]] (%ctime <= $1) {
 
      [[hadd]] %table %id $+ %n $1 %nick $3
 
      [[If-Then-Else|if]] ($2 == 0) {
 
        [[hadd]] %table %id $+ %nick %ctime 0 %n
 
        [[hadd]] %table %id $+ -firstnick %nick
 
      }
 
      [[If-Then-Else|else]] {
 
        [[hadd]] %table %id $+ %nick %ctime $2 %n
 
        [[hadd]] %table %id $+ $2 $gettok($hget(%table,%id $+ $2),1-2,32) %nick
 
      }
 
      [[break]]
 
    }
 
    [[Local_Variables|var]] %n = $3
 
  }
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.Q.ADD.MAIN ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; $1 = nick
 
[[alias]] -l auth.q.add.main {
 
  [[If-Then-Else|if]] (!$hget(auths.q. $+ $cid)) { [[return]] }
 
  [[hadd]] auths.q. $+ $cid $1 $ctime
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.Q.REM ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; $1 = nick
 
[[alias]] -l auth.q.rem {
 
  [[If-Then-Else|if]] (!$hget(auths.q. $+ $cid)) { [[return]] }
 
  [[Local_Variables|var]] %i = $comchan($1,0)
 
  [[while]] (%i) {
 
    auth.q.rem.wid $chan($comchan($1,%i)).wid $1
 
    [[dec]] %i
 
  }
 
  auth.q.rem.main $1
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.Q.REM.WID ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; $1 = wid  $2 = nick
 
[[alias]] -l auth.q.rem.wid {
 
  [[Local_Variables|var]] %table = auths.q. $+ $cid
 
  [[If-Then-Else|if]] (!$hget(%table)) { [[return]] }
 
  [[Local_Variables|var]] %id = $1 $+ . , %val = $hget(%table,%id $+ $2)
 
  [[If-Then-Else|if]] (!%val) { [[return]] }
 
  [[Local_Variables|var]] %nick.l = $gettok(%val,2,32) , %nick.r = $gettok(%val,3,32)
 
  [[hdel]] %table %id $+ $2
 
  [[If-Then-Else|if]] (%nick.l == 0) && (%nick.r == 0) { [[hdel]] %table %id $+ -lastnick | [[hdel]] %table %id $+ -firstnick | [[return]] }
 
  [[If-Then-Else|if]] (%nick.l !== 0) { [[hadd]] %table %id $+ %nick.l $gettok($hget(%table,%id $+ %nick.l),1-2,32) %nick.r }
 
  [[If-Then-Else|else]] { [[hadd]] %table %id $+ -firstnick %nick.r }
 
  [[If-Then-Else|if]] (%nick.r !== 0) { [[hadd]] %table %id $+ %nick.r $gettok($hget(%table,%id $+ %nick.r),1,32) %nick.l $gettok($hget(%table,%id $+ %nick.r),3,32) }
 
  [[If-Then-Else|else]] { [[hadd]] %table %id $+ -lastnick %nick.l }
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.Q.REM.MAIN ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; $1 = nick
 
[[alias]] -l auth.q.rem.main {
 
  [[If-Then-Else|if]] (!$hget(auths.q. $+ $cid)) { [[return]] }
 
  [[hdel]] auths.q. $+ $cid $1
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.Q.REM.CHAN.ALL ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; $1 = chan
 
[[alias]] -l auth.q.rem.chan.all {
 
  [[Local_Variables|var]] %table = auths.q. $+ $cid
 
  [[If-Then-Else|if]] (!$hget(%table)) { [[return]] }
 
  [[hdel]] -w %table $chan($1).wid $+ .*
 
  [[Local_Variables|var]] %i = $nick($1,0)
 
  [[while]] (%i) {
 
    [[If-Then-Else|if]] (!$comchan($nick($1,%i),2)) { [[hdel]] %table $nick($1,%i) }
 
    [[dec]] %i
 
  }
 
}
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.Q.NICK ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; $1 = nick  $2 = newnick
 
[[alias]] -l auth.q.nick {
 
  [[If-Then-Else|if]] ($1 == $2) { [[return]] }
 
  [[Local_Variables|var]] %table = auths.q. $+ $cid
 
  [[If-Then-Else|if]] (!$hget(%table)) { [[return]] }
 
  [[Local_Variables|var]] %i = $comchan($2,0)
 
  [[while]] (%i) {
 
    [[Local_Variables|var]] %id = $chan($comchan($2,%i)).wid $+ . , %val = $hget(%table,%id $+ $1)
 
    [[If-Then-Else|if]] (%val) {
 
      [[hdel]] %table %id $+ $1
 
      [[hadd]] %table %id $+ $2 %val
 
      [[Local_Variables|var]] %nick.l = $gettok(%val,2,32) , %nick.r = $gettok(%val,3,32)
 
      [[If-Then-Else|if]] (%nick.l !== 0) { [[hadd]] %table %id $+ %nick.l $gettok($hget(%table,%id $+ %nick.l),1-2,32) $2 }
 
      [[If-Then-Else|else]] { [[hadd]] %table %id $+ -firstnick $2 }
 
      [[If-Then-Else|if]] (%nick.r !== 0) { [[hadd]] %table %id $+ %nick.r $gettok($hget(%table,%id $+ %nick.r),1,32) $2 $gettok($hget(%table,%id $+ %nick.r),3,32) }
 
      [[If-Then-Else|else]] { [[hadd]] %table %id $+ -lastnick $2 }
 
    }
 
    [[dec]] %i
 
  }
 
  [[If-Then-Else|if]] ($hget(%table,$1) !== $null) { [[hdel]] %table $1 | [[hadd]] %table $2 $v1 }
 
}
 
 
 
 
; ----------------------------------------------------------------------------------------------------
 
; --------------------------------------- AUTHS - NEXT - TABLE ---------------------------------------
 
; ----------------------------------------------------------------------------------------------------
 
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.N.ADD ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; $1 = nick
 
[[alias]] -l auth.n.add {
 
  [[If-Then-Else|if]] (!$hget(auths.n. $+ $cid)) { [[return]] }
 
  auth.n.add.main $1
 
  [[Local_Variables|var]] %i = $comchan($1,0)
 
  [[while]] (%i) {
 
    auth.n.add.wid $chan($comchan($1,%i)).wid $1
 
    [[dec]] %i
 
  }
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.N.ADD.WID ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; $1 = wid  $2 = nick
 
[[alias]] -l auth.n.add.wid {
 
  [[Local_Variables|var]] %table = auths.n. $+ $cid
 
  [[If-Then-Else|if]] (!$hget(%table)) { [[return]] }
 
  [[Local_Variables|var]] %id = $1 $+ . ,  %lastnick = $hget(%table,%id $+ -lastnick)
 
  [[If-Then-Else|if]] ($hget(%table,%id $+ $2)) { [[return]] }
 
  [[If-Then-Else|if]] (%lastnick) {
 
    [[hadd]] %table %id $+ $2 %lastnick 0
 
    [[hadd]] %table %id $+ %lastnick $gettok($hget(%table,%id $+ %lastnick),1,32) $2
 
  }
 
  [[If-Then-Else|else]] {
 
    [[hadd]] %table %id $+ $2 0 0
 
    [[hadd]] %table %id $+ -firstnick $2
 
  }
 
  [[hadd]] %table %id $+ -lastnick $2
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.N.ADD.MAIN ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; $1 = nick
 
[[alias]] -l auth.n.add.main {
 
  [[Local_Variables|var]] %table = auths.n. $+ $cid
 
  [[If-Then-Else|if]] (!$hget(%table)) { [[return]] }
 
  [[Local_Variables|var]] %lastnick = $hget(%table,-lastnick)
 
  [[If-Then-Else|if]] ($hget(%table,$1)) { [[return]] }
 
  [[If-Then-Else|if]] (%lastnick) {
 
    [[hadd]] %table $1 %lastnick 0
 
    [[hadd]] %table %lastnick $gettok($hget(%table,%lastnick),1,32) $1
 
  }
 
  [[If-Then-Else|else]] {
 
    [[hadd]] %table $1 0 0
 
    [[hadd]] %table -firstnick $1
 
  }
 
  [[hadd]] %table -lastnick $1
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.N.REM ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; $1 = nick
 
[[alias]] -l auth.n.rem {
 
  [[If-Then-Else|if]] (!$hget(auths.n. $+ $cid)) { [[return]] }
 
  [[Local_Variables|var]] %i = $comchan($1,0)
 
  [[while]] (%i) {
 
    auth.n.rem.wid $chan($comchan($1,%i)).wid $1
 
    [[dec]] %i
 
  }
 
  auth.n.rem.main $1
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.N.REM.WID ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; $1 = wid  $2 = nick
 
[[alias]] -l auth.n.rem.wid {
 
  [[Local_Variables|var]] %table = auths.n. $+ $cid
 
  [[If-Then-Else|if]] (!$hget(%table)) { [[return]] }
 
  [[Local_Variables|var]] %id = $1 $+ . , %val = $hget(%table,%id $+ $2)
 
  [[If-Then-Else|if]] (!%val) { [[return]] }
 
  [[Local_Variables|var]] %nick.l = $gettok(%val,1,32) , %nick.r = $gettok(%val,2,32)
 
  [[hdel]] %table %id $+ $2
 
  [[If-Then-Else|if]] (%nick.l == 0) && (%nick.r == 0) { [[hdel]] %table %id $+ -lastnick | [[hdel]] %table %id $+ -firstnick | [[return]] }
 
  [[If-Then-Else|if]] (%nick.l !== 0) { [[hadd]] %table %id $+ %nick.l $gettok($hget(%table,%id $+ %nick.l),1,32) %nick.r }
 
  [[If-Then-Else|else]] { [[hadd]] %table %id $+ -firstnick %nick.r }
 
  [[If-Then-Else|if]] (%nick.r !== 0) { [[hadd]] %table %id $+ %nick.r %nick.l $gettok($hget(%table,%id $+ %nick.r),2,32) }
 
  [[If-Then-Else|else]] { [[hadd]] %table %id $+ -lastnick %nick.l }
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.N.REM.MAIN ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; $1 = nick
 
[[alias]] -l auth.n.rem.main {
 
  [[Local_Variables|var]] %table = auths.n. $+ $cid
 
  [[If-Then-Else|if]] (!$hget(%table)) { [[return]] }
 
  [[Local_Variables|var]] %val = $hget(%table,$1)
 
  [[If-Then-Else|if]] (!%val) { [[return]] }
 
  [[Local_Variables|var]] %nick.l = $gettok(%val,1,32) , %nick.r = $gettok(%val,2,32)
 
  [[hdel]] %table $1
 
  [[If-Then-Else|if]] (%nick.l == 0) && (%nick.r == 0) { [[hdel]] %table -lastnick | [[hdel]] %table -firstnick | [[return]] }
 
  [[If-Then-Else|if]] (%nick.l !== 0) { [[hadd]] %table %nick.l $gettok($hget(%table,%nick.l),1,32) %nick.r }
 
  [[If-Then-Else|else]] { [[hadd]] %table -firstnick %nick.r }
 
  [[If-Then-Else|if]] (%nick.r !== 0) { [[hadd]] %table %nick.r %nick.l $gettok($hget(%table,%nick.r),2,32) }
 
  [[If-Then-Else|else]] { [[hadd]] %table -lastnick %nick.l }
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.N.REM.CHAN.ALL ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; $1 = chan
 
[[alias]] -l auth.n.rem.chan.all {
 
  [[Local_Variables|var]] %table = auths.n. $+ $cid
 
  [[If-Then-Else|if]] (!$hget(%table)) { [[return]] }
 
  [[hdel]] -w %table $chan($1).wid $+ .*
 
  [[Local_Variables|var]] %i = $nick($1,0)
 
  [[while]] (%i) {
 
    [[If-Then-Else|if]] (!$comchan($nick($1,%i),2)) { auth.n.rem.main $nick($1,%i) }
 
    [[dec]] %i
 
  }
 
}
 
 
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.N.NICK ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
; $1 = nick  $2 = newnick
 
[[alias]] -l auth.n.nick {
 
  [[If-Then-Else|if]] ($1 == $2) { [[return]] }
 
  [[Local_Variables|var]] %table = auths.n. $+ $cid
 
  [[If-Then-Else|if]] (!$hget(%table)) { [[return]] }
 
  [[Local_Variables|var]] %i = $comchan($2,0)
 
  [[while]] (%i) {
 
    [[Local_Variables|var]] %id = $chan($comchan($2,%i)).wid $+ . , %val = $hget(%table,%id $+ $1)
 
    [[If-Then-Else|if]] (%val) {
 
      [[hdel]] %table %id $+ $1
 
      [[hadd]] %table %id $+ $2 %val
 
      [[Local_Variables|var]] %nick.l = $gettok(%val,1,32) , %nick.r = $gettok(%val,2,32)
 
      [[If-Then-Else|if]] (%nick.l !== 0) { [[hadd]] %table %id $+ %nick.l $gettok($hget(%table,%id $+ %nick.l),1,32) $2 }
 
      [[If-Then-Else|else]] { [[hadd]] %table %id $+ -firstnick $2 }
 
      [[If-Then-Else|if]] (%nick.r !== 0) { [[hadd]] %table %id $+ %nick.r $2 $gettok($hget(%table,%id $+ %nick.r),2,32) }
 
      [[If-Then-Else|else]] { [[hadd]] %table %id $+ -lastnick $2 }
 
    }
 
    [[dec]] %i
 
  }
 
  [[Local_Variables|var]] %val = $hget(%table,$1)
 
  [[If-Then-Else|if]] (%val) {
 
    [[hdel]] %table $1
 
    [[hadd]] %table $2 %val
 
    [[Local_Variables|var]] %nick.l = $gettok(%val,1,32) , %nick.r = $gettok(%val,2,32)
 
    [[If-Then-Else|if]] (%nick.l !== 0) { [[hadd]] %table %nick.l $gettok($hget(%table,%nick.l),1,32) $2 }
 
    [[If-Then-Else|else]] { [[hadd]] %table -firstnick $2 }
 
    [[If-Then-Else|if]] (%nick.r !== 0) { [[hadd]] %table %nick.r $2 $gettok($hget(%table,%nick.r),2,32) }
 
    [[If-Then-Else|else]] { [[hadd]] %table -lastnick $2 }
 
  }
 
}
 
 
bla
 
 
 
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; IAL-UPDATE ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; IAL-UPDATE ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
  ;info:
 
  ;info:
Line 967: Line 63:
 
  on *:join:#:{
 
  on *:join:#:{
 
   ; we join, IAL not updated, timer does not run, start a timer
 
   ; we join, IAL not updated, timer does not run, start a timer
   [[If-Then-Else|if]] ($nick == $me) && (!$timer($+($cid,.ial-update.update))) {
+
   [[If-Then-Else|if]] ([[$nick_(remote)|$nick]] == [[$me]]) && (![[|$timer]]([[DollarPlus|$+]]([[$cid]],.ial-update.update))) {
     .![[timer]] $+ $cid $+ .ial-update.update 1 $$delay.who ial-update.update
+
     .![[timer]] [[DollarPlus|$+]] [[$cid]] [[DollarPlus|$+]] .ial-update.update 1 $$delay.who ial-update.update
 
   }
 
   }
 
  }
 
  }
 
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; LOAD EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; LOAD EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  on *:load:{ !scon -at1 .!timer $!+ $!cid $!+ .ial-update.update 1 $$delay.who ial-update.update }
+
  on *:load:{ !scon -at1 .!timer [[$!]][[DollarPlus|+]] [[$!]][[cid]] [[$!]][[DollarPlus|+]] .ial-update.update 1 $$delay.who ial-update.update }
 
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS IALUPDATE ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS IALUPDATE ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
  [[alias]] ialupdate { ![[echo]] -a IAL-update: $ial-update.update }
 
  [[alias]] ialupdate { ![[echo]] -a IAL-update: $ial-update.update }
Line 979: Line 75:
 
   ![[Local_Variables|var]] %c, %n
 
   ![[Local_Variables|var]] %c, %n
 
   ; IAL is set on
 
   ; IAL is set on
   [[If-Then-Else|if]] ($ial) {
+
   [[If-Then-Else|if]] ([[$ial]]) {
 
     ; hash table does not exist, set a var with the channels we need to who
 
     ; hash table does not exist, set a var with the channels we need to who
     [[If-Then-Else|if]] (!$hget($+(ial-update.,$cid))) { ![[Local_Variables|var]] %c = $ial-update.chan($max.who,$len.who)
+
     [[If-Then-Else|if]] (![[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]))) { ![[Local_Variables|var]] %c = [[|$ial-update.chan]]($max.who,$len.who)
 
       ; something is in there, send it to the hash alias, send the who request
 
       ; something is in there, send it to the hash alias, send the who request
 
       [[If-Then-Else|if]] (%c) { ial-update.hash %c | .!quote WHO %c }
 
       [[If-Then-Else|if]] (%c) { ial-update.hash %c | .!quote WHO %c }
 
       ; else no channels to who, set a var with the nicks we need to who
 
       ; else no channels to who, set a var with the nicks we need to who
       [[If-Then-Else|else]] { ![[Local_Variables|var]] %n = $ial-update.nick($max.who,$len.who)
+
       [[If-Then-Else|else]] { ![[Local_Variables|var]] %n = [[|$ial-update.nick]]($max.who,$len.who)
 
         ; something is in there, send it to the hash alias, send the who request
 
         ; something is in there, send it to the hash alias, send the who request
 
         [[If-Then-Else|if]] (%n) { ial-update.hash %n | .!quote WHO %n  }
 
         [[If-Then-Else|if]] (%n) { ial-update.hash %n | .!quote WHO %n  }
Line 991: Line 87:
 
     }
 
     }
 
     ; we did a who or the hash table was not empty, start a timer to run this alias again
 
     ; we did a who or the hash table was not empty, start a timer to run this alias again
     [[If-Then-Else|if]] (%c) || (%n) || ($hget($+(ial-update.,$cid))) {
+
     [[If-Then-Else|if]] (%c) || (%n) || ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]))) {
       .![[timer]] $+ $cid $+ .ial-update.update 1 $$repeat.who ial-update.update
+
       .![[timer]] [[DollarPlus|$+]] [[$cid]] [[DollarPlus|$+]] .ial-update.update 1 $$repeat.who ial-update.update
 
     }
 
     }
 
     ; return some info
 
     ; return some info
 
     [[If-Then-Else|if]] (%c) || (%n) { ![[return]] updating }
 
     [[If-Then-Else|if]] (%c) || (%n) { ![[return]] updating }
     [[If-Then-Else|elseif]] ($hget($+(ial-update.,$cid))) { ![[return]] already in progress }
+
     [[If-Then-Else|elseif]] ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]))) { ![[return]] already in progress }
 
     [[If-Then-Else|else]] { ![[return]] nothing to update }
 
     [[If-Then-Else|else]] { ![[return]] nothing to update }
 
   }
 
   }
Line 1,012: Line 108:
 
   ; $chan(0) returns the number of open channel windows,
 
   ; $chan(0) returns the number of open channel windows,
 
   ; which does not mean you are on it ("keep channels open" option)
 
   ; which does not mean you are on it ("keep channels open" option)
   [[while]] (%x <= $comchan($me,0)) {
+
   [[while]] (%x <= [[$comchan]]([[$me]],0)) {
 
     ; check if the ial is not updated or busy, add it to a var
 
     ; check if the ial is not updated or busy, add it to a var
     [[If-Then-Else|if]] ($chan($comchan($me,%x)).ial == $false) { ![[Local_Variables|var]] %c =  $addtok(%c,$+($nick($comchan($me,%x),0),.,%x),32) }
+
     [[If-Then-Else|if]] ([[$chan_(window)|$chan(]][[$comchan]]([[$me]],%x)).ial == $false) { ![[Local_Variables|var]] %c =  [[$addtok]](%c,[[DollarPlus|$+]]([[$nick_(nick)|$nick(]][[$comchan]]([[$me]],%x),0),.,%x),32) }
 
     ![[inc]] %x
 
     ![[inc]] %x
 
   }
 
   }
 
   ; return it sorted
 
   ; return it sorted
   ![[return]] $sorttok(%c,32,n)
+
   ![[return]] [[$sorttok]](%c,32,n)
 
  }
 
  }
 
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS IAL-UPDATE.MAX ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS IAL-UPDATE.MAX ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
Line 1,028: Line 124:
 
   ![[Local_Variables|var]] %x = 1, %t = 0, %c = $ial-update.sort, %w
 
   ![[Local_Variables|var]] %x = 1, %t = 0, %c = $ial-update.sort, %w
 
   ; loop through the channels and as long as %t smaller then $1, increase %t
 
   ; loop through the channels and as long as %t smaller then $1, increase %t
   [[while]] (%x <= $numtok(%c,32)) && (%t < $1) {
+
   [[while]] (%x <= [[$numtok]](%c,32)) && (%t < [[$1|$1]]) {
     ![[inc]] %t $gettok($gettok(%c,%x,32),1,46)
+
     ![[inc]] %t [[$gettok]]([[$gettok]](%c,%x,32),1,46)
 
     ; if %t is greater then $1, stop the loop
 
     ; if %t is greater then $1, stop the loop
     [[If-Then-Else|if]] (%t > $1) { ![[break]] }
+
     [[If-Then-Else|if]] (%t > [[$1|$1]]) { ![[break]] }
 
     ; add it to a var
 
     ; add it to a var
     ![[Local_Variables|var]] %w = $addtok(%w,$gettok($gettok(%c,%x,32),2,46),32)
+
     ![[Local_Variables|var]] %w = [[$addtok]](%w,[[$gettok]]([[$gettok]](%c,%x,32),2,46),32)
 
     ![[inc]] %x
 
     ![[inc]] %x
 
   }
 
   }
Line 1,044: Line 140:
 
  ; this alias is used to WHO channels
 
  ; this alias is used to WHO channels
 
  [[alias]] -l ial-update.chan {
 
  [[alias]] -l ial-update.chan {
   ![[Local_Variables|var]] %x = 1, %l = 0, %c = $ial-update.max($1), %w
+
   ![[Local_Variables|var]] %x = 1, %l = 0, %c = [[|$ial-update.max]]([[$1|$1]]), %w
 
   ; loop through the channels, as long as %l smaller then $2, increase %l for the length of the  channel
 
   ; loop through the channels, as long as %l smaller then $2, increase %l for the length of the  channel
   [[while]] (%x <= $numtok(%c,32)) && (%l < $2) {
+
   [[while]] (%x <= [[$numtok]](%c,32)) && (%l < [[$1|$2]]) {
     ![[inc]] %l $len($comchan($me,$gettok(%c,%x,32)))
+
     ![[inc]] %l [[$len]]([[$comchan]]([[$me]],[[$gettok]](%c,%x,32)))
 
     ; %l greater then $2, stop the loop
 
     ; %l greater then $2, stop the loop
     [[If-Then-Else|if]] (%l > $2) { ![[break]] }
+
     [[If-Then-Else|if]] (%l > [[$1|$2]]) { ![[break]] }
 
     ; add it to the var
 
     ; add it to the var
     ![[Local_Variables|var]] %w = $addtok(%w,$comchan($me,$gettok(%c,%x,32)),44)
+
     ![[Local_Variables|var]] %w = [[$addtok]](%w,[[$comchan]]([[$me]],[[$gettok]](%c,%x,32)),44)
 
     ![[inc]] %x
 
     ![[inc]] %x
 
   }
 
   }
Line 1,064: Line 160:
 
   ![[Local_Variables|var]] %x = 1
 
   ![[Local_Variables|var]] %x = 1
 
   ; loop through the channels untill we found one where the IAL isnt updated
 
   ; loop through the channels untill we found one where the IAL isnt updated
   [[while]] ($chan($comchan($me,%x)).ial != $false) && (%x <= $comchan($me,0)) {
+
   [[while]] ([[$chan_(window)|$chan(]][[$comchan]]([[$me]],%x)).ial != $false) && (%x <= [[$comchan]]([[$me]],0)) {
 
     ![[inc]] %x
 
     ![[inc]] %x
 
   }
 
   }
 
   ; ial is not updated, set vars
 
   ; ial is not updated, set vars
   [[If-Then-Else|if]] ($chan($comchan($me,%x)).ial == $false) { ![[Local_Variables|var]] %y = 1, %t = 0, %l = 0, %w
+
   [[If-Then-Else|if]] ([[$chan_(window)|$chan(]][[$comchan]]([[$me]],%x)).ial == $false) { ![[Local_Variables|var]] %y = 1, %t = 0, %l = 0, %w
 
     ; loop
 
     ; loop
     [[while]] (%t <= $1) && (%l < $2) && (%y <= $nick($comchan($me,%x),0)) {
+
     [[while]] (%t <= [[$1|$1]]) && (%l < [[$1|$2]]) && (%y <= [[$nick_(nick)|$nick(]][[$comchan]]([[$me]],%x),0)) {
 
       ; ial for that nick isnt updated, increase %l
 
       ; ial for that nick isnt updated, increase %l
       [[If-Then-Else|if]] (!$ial($nick($comchan($me,%x),%y))) {
+
       [[If-Then-Else|if]] (![[$ial]]([[$nick_(nick)|$nick(]][[$comchan]]([[$me]],%x),%y))) {
         ![[inc]] %l $len($nick($comchan($me,%x),%y))
+
         ![[inc]] %l [[$len]]([[$nick_(nick)|$nick(]][[$comchan]]([[$me]],%x),%y))
 
         ; if greater then $2, stop the loop
 
         ; if greater then $2, stop the loop
         [[If-Then-Else|if]] (%l > $2) { ![[break]] }
+
         [[If-Then-Else|if]] (%l > [[$1|$2]]) { ![[break]] }
 
         ; add it to the var
 
         ; add it to the var
         ![[Local_Variables|var]] %w = $addtok(%w,$nick($comchan($me,%x),%y),44)
+
         ![[Local_Variables|var]] %w = [[$addtok]](%w,[[$nick_(nick)|$nick(]][[$comchan]]([[$me]],%x),%y),44)
 
       }
 
       }
 
       ![[inc]] %y
 
       ![[inc]] %y
Line 1,088: Line 184:
 
  [[alias]] -l ial-update.hash {
 
  [[alias]] -l ial-update.hash {
 
   ; $2 is not there, set a var
 
   ; $2 is not there, set a var
   [[If-Then-Else|if]] ($2 == $null) { ![[Local_Variables|var]] %x = $numtok($1,44)
+
   [[If-Then-Else|if]] ([[$1|$2]] == [[$null]]) { ![[Local_Variables|var]] %x = [[$numtok]]([[$1|$1]],44)
 
     ; loop through each part seperated with a comma, add it to a hash table
 
     ; loop through each part seperated with a comma, add it to a hash table
     [[while]] (%x) { ![[hadd]] -m $+(ial-update.,$cid) $gettok($1,%x,44) 1 | ![[dec]] %x }
+
     [[while]] (%x) { ![[hadd]] -m [[DollarPlus|$+]](ial-update.,[[$cid]]) [[$gettok]]([[$1|$1]],%x,44) 1 | ![[dec]] %x }
 
     ; add mask
 
     ; add mask
     ![[hadd]] -m $+(ial-update.,$cid) -mask $1
+
     ![[hadd]] -m [[DollarPlus|$+]](ial-update.,[[$cid]]) -mask [[$1|$1]]
 
   }
 
   }
 
   ; $2 is -remove, set a var
 
   ; $2 is -remove, set a var
   [[If-Then-Else|elseif]] ($2 == -remove) { ![[Local_Variables|var]] %x = $numtok($1,44)
+
   [[If-Then-Else|elseif]] ([[$1|$2]] == -remove) { ![[Local_Variables|var]] %x = [[$numtok]]([[$1|$1]],44)
 
     ; loop through each part seperated with a comma, remove it from the hash table
 
     ; loop through each part seperated with a comma, remove it from the hash table
     [[while]] (%x) { [[If-Then-Else|if]] ($hget($+(ial-update.,$cid))) { ![[hdel]] $+(ial-update.,$cid) $gettok($1,%x,44) } | ![[dec]] %x }
+
     [[while]] (%x) { [[If-Then-Else|if]] ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]))) { ![[hdel]] [[DollarPlus|$+]](ial-update.,[[$cid]]) [[$gettok]]([[$1|$1]],%x,44) } | ![[dec]] %x }
 
     ; del mask
 
     ; del mask
     ![[hdel]] $+(ial-update.,$cid) -mask
+
     ![[hdel]] [[DollarPlus|$+]](ial-update.,[[$cid]]) -mask
 
     ; check hash table, free hash table
 
     ; check hash table, free hash table
     [[If-Then-Else|if]] ($hget($+(ial-update.,$cid),0).item == 0) && ($hget($+(ial-update.,$cid))) { ![[hfree]] $+(ial-update.,$cid) }
+
     [[If-Then-Else|if]] ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]),0).item == 0) && ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]))) { ![[hfree]] [[DollarPlus|$+]](ial-update.,[[$cid]]) }
 
   }
 
   }
 
  }
 
  }
Line 1,108: Line 204:
 
  raw 352:& & & & & & & & *: {
 
  raw 352:& & & & & & & & *: {
 
   ; chan or nick are in the hash table
 
   ; chan or nick are in the hash table
   [[If-Then-Else|if]] ($hget($+(ial-update.,$cid),$2)) || ($hget($+(ial-update.,$cid),$6)) {
+
   [[If-Then-Else|if]] ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]),[[$1|$2]])) || ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]),[[$1|$6]])) {
 
     ; check setting, set a var
 
     ; check setting, set a var
     [[If-Then-Else|if]] ($show.who == 1) && ($hget($+(ial-update.,$cid),$2)) && ($comchan($6,0)) { ![[Local_Variables|var]] %x = $comchan($6,0)
+
     [[If-Then-Else|if]] ($show.who == 1) && ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]),[[$1|$2]])) && ([[$comchan]]([[$1|$6]],0)) { ![[Local_Variables|var]] %x = [[$comchan]]([[$1|$6]],0)
 
       ; loop, set a var
 
       ; loop, set a var
       [[while]] (%x) { ![[Local_Variables|var]] %c = $comchan($6,%x)
+
       [[while]] (%x) { ![[Local_Variables|var]] %c = [[$comchan]]([[$1|$6]],%x)
 
         ; check has table
 
         ; check has table
         [[If-Then-Else|if]] ($hget($+(ial-update.,$cid),%c)) {
+
         [[If-Then-Else|if]] ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]),%c)) {
 
           ; * meaning oper isin $7, increase
 
           ; * meaning oper isin $7, increase
           [[If-Then-Else|if]] (* isin $7) { ![[hinc]] $+(ial-update.,$cid) $+(%c,$chr(44),oper) }
+
           [[If-Then-Else|if]] (* isin [[$1|$7]]) { ![[hinc]] [[DollarPlus|$+]](ial-update.,[[$cid]]) [[DollarPlus|$+]](%c,[[$chr]](44),oper) }
 
           ; G meaning Gone isin $7, increase
 
           ; G meaning Gone isin $7, increase
           [[If-Then-Else|if]] (G isincs $7) { ![[hinc]] $+(ial-update.,$cid) $+(%c,$chr(44),away) }
+
           [[If-Then-Else|if]] (G isincs [[$1|$7]]) { ![[hinc]] [[DollarPlus|$+]](ial-update.,[[$cid]]) [[DollarPlus|$+]](%c,[[$chr]](44),away) }
 
           ; d meaning deaf isin $7, increase
 
           ; d meaning deaf isin $7, increase
           [[If-Then-Else|if]] (d isincs $7) { ![[hinc]] $+(ial-update.,$cid) $+(%c,$chr(44),deaf) }
+
           [[If-Then-Else|if]] (d isincs [[$1|$7]]) { ![[hinc]] [[DollarPlus|$+]](ial-update.,[[$cid]]) [[DollarPlus|$+]](%c,[[$chr]](44),deaf) }
 
           ; x meaning fake host isin $7, increase
 
           ; x meaning fake host isin $7, increase
           [[If-Then-Else|if]] (x isincs $7) { ![[hinc]] $+(ial-update.,$cid) $+(%c,$chr(44),xhost) }
+
           [[If-Then-Else|if]] (x isincs [[$1|$7]]) { ![[hinc]] [[DollarPlus|$+]](ial-update.,[[$cid]]) [[DollarPlus|$+]](%c,[[$chr]](44),xhost) }
 
         }
 
         }
 
         ![[dec]] %x
 
         ![[dec]] %x
Line 1,135: Line 231:
 
  raw 315:& & end of /WHO list.: {
 
  raw 315:& & end of /WHO list.: {
 
   ; check -mask in hash table
 
   ; check -mask in hash table
   [[If-Then-Else|if]] ($hget($+(ial-update.,$cid),-mask) == $2) {
+
   [[If-Then-Else|if]] ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]),-mask) == [[$1|$2]]) {
 
     ; check setting, set a var
 
     ; check setting, set a var
     [[If-Then-Else|if]] ($show.who == 1) { ![[Local_Variables|var]] %x = $numtok($2,44)
+
     [[If-Then-Else|if]] ($show.who == 1) { ![[Local_Variables|var]] %x = [[$numtok]]([[$1|$2]],44)
 
       ; loop, we are on the channel, set var
 
       ; loop, we are on the channel, set var
       [[while]] (%x) { [[If-Then-Else|if]] ($me ison $gettok($2,%x,44)) { ![[Local_Variables|var]] %c = $gettok($2,%x,44)
+
       [[while]] (%x) { [[If-Then-Else|if]] ([[$me]] ison [[$gettok]]([[$1|$2]],%x,44)) { ![[Local_Variables|var]] %c = [[$gettok]]([[$1|$2]],%x,44)
 
           ; oper info
 
           ; oper info
           ![[Local_Variables|var]] %oper = $iif($hget($+(ial-update.,$cid),$+(%c,$chr(44),oper)),$ifmatch,0)
+
           ![[Local_Variables|var]] %oper = [[$iif]]([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]),[[DollarPlus|$+]](%c,[[$chr]](44),oper)),[[$ifmatch]],0)
           ![[Local_Variables|var]] %oper = %oper / $round($calc(%oper / $nick(%c,0) * 100),1) $+ % Oper
+
           ![[Local_Variables|var]] %oper = %oper / [[$round]]([[$calc]](%oper / [[$nick_(nick)|$nick(]]%c,0) * 100),1) [[DollarPlus|$+]] % Oper
 
           ; away info
 
           ; away info
           ![[Local_Variables|var]] %away = $iif($hget($+(ial-update.,$cid),$+(%c,$chr(44),away)),$ifmatch,0)
+
           ![[Local_Variables|var]] %away = [[$iif]]([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]),[[DollarPlus|$+]](%c,[[$chr]](44),away)),[[$ifmatch]],0)
           ![[Local_Variables|var]] %away = %away / $round($calc(%away / $nick(%c,0) * 100),1) $+ % Away
+
           ![[Local_Variables|var]] %away = %away / [[$round]]([[$calc]](%away / [[$nick_(nick)|$nick(]]%c,0) * 100),1) [[DollarPlus|$+]] % Away
 
           ; deaf info
 
           ; deaf info
           ![[Local_Variables|var]] %deaf = $iif($hget($+(ial-update.,$cid),$+(%c,$chr(44),deaf)),$ifmatch,0)
+
           ![[Local_Variables|var]] %deaf = [[$iif]]([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]),[[DollarPlus|$+]](%c,[[$chr]](44),deaf)),[[$ifmatch]],0)
           ![[Local_Variables|var]] %deaf = %deaf / $round($calc(%deaf / $nick(%c,0) * 100),1) $+ % deaf
+
           ![[Local_Variables|var]] %deaf = %deaf / [[$round]]([[$calc]](%deaf / [[$nick_(nick)|$nick(]]%c,0) * 100),1) [[DollarPlus|$+]] % deaf
 
           ; xhost info
 
           ; xhost info
           ![[Local_Variables|var]] %xhost = $iif($hget($+(ial-update.,$cid),$+(%c,$chr(44),xhost)),$ifmatch,0)
+
           ![[Local_Variables|var]] %xhost = [[$iif]]([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]),[[DollarPlus|$+]](%c,[[$chr]](44),xhost)),[[$ifmatch]],0)
           ![[Local_Variables|var]] %xhost = %xhost / $round($calc(%xhost / $nick(%c,0) * 100),1) $+ % x-host
+
           ![[Local_Variables|var]] %xhost = %xhost / [[$round]]([[$calc]](%xhost / [[$nick_(nick)|$nick(]]%c,0) * 100),1) [[DollarPlus|$+]] % x-host
 
           ; echo
 
           ; echo
           ![[echo]] -t $gettok($2,%x,44) * IAL updated ( $+ %oper ---- %away ---- %deaf ---- %xhost $+ )
+
           ![[echo]] -t [[$gettok]]([[$1|$2]],%x,44) * IAL updated ( [[DollarPlus|$+]] %oper ---- %away ---- %deaf ---- %xhost [[DollarPlus|$+]] )
 
         }
 
         }
 
         ; remove from hash table
 
         ; remove from hash table
         ![[hdel]] $+(ial-update.,$cid) $+(%c,$chr(44),oper) | ![[hdel]] $+(ial-update.,$cid) $+(%c,$chr(44),away)
+
         ![[hdel]] [[DollarPlus|$+]](ial-update.,[[$cid]]) [[DollarPlus|$+]](%c,[[$chr]](44),oper) | ![[hdel]] [[DollarPlus|$+]](ial-update.,[[$cid]]) [[DollarPlus|$+]](%c,[[$chr]](44),away)
         ![[hdel]] $+(ial-update.,$cid) $+(%c,$chr(44),deaf) | ![[hdel]] $+(ial-update.,$cid) $+(%c,$chr(44),xhost)
+
         ![[hdel]] [[DollarPlus|$+]](ial-update.,[[$cid]]) [[DollarPlus|$+]](%c,[[$chr]](44),deaf) | ![[hdel]] [[DollarPlus|$+]](ial-update.,[[$cid]]) [[DollarPlus|$+]](%c,[[$chr]](44),xhost)
 
         ![[dec]] %x
 
         ![[dec]] %x
 
       }
 
       }
 
     }
 
     }
 
     ; remove the items from the hash table
 
     ; remove the items from the hash table
     ial-update.hash $2 -remove
+
     ial-update.hash [[$1|$2]] -remove
 
     ![[haltdef]]
 
     ![[haltdef]]
 
   }
 
   }
 
  }
 
  }
 
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; DISCONNECT EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; DISCONNECT EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  on *:disconnect:{ [[If-Then-Else|if]] ($hget($+(ial-update.,$cid))) { ![[hfree]] $+(ial-update.,$cid) } }
+
  on *:disconnect:{ [[If-Then-Else|if]] ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]))) { ![[hfree]] [[DollarPlus|$+]](ial-update.,[[$cid]]) } }

Revision as of 13:55, 3 February 2011

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; IAL-UPDATE ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;info:
;
;  by wiebe @ QuakeNet
;  version 1.0  (written and tested on mIRC 6.15)
;
;  last edit: Sun Jun 06 2004
;
;
;What does this script do?
;
;  updates the IAL by doing /who chan1,chan2,chan3 etc
;  if a channel is too big, /who nick1,nick2,nick3 etc is done untill the IAL for the channel is   updated
;  script updates from smallest to the biggest channel
;
;
;How to use this script?
;
;  config the options below
;  /ialupdate can be used to make the script update the IAL without waiting for the timer to  trigger it
;
;
;Why is this script good?
;
;  sending /who chan for every channel is not needed and goes slow (lag)
;  sending /who chan on join may cause Excess Flood or Max sendQ exceeded
;  sending /who chan1,chan2,chan3 can be much faster, but only if there are not too many results  (Max sendQ exceeded)
;
;
;  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS MAX.WHO ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
alias -l max.who {
 ; maximum number of replies in a WHO, too big may cause 'Max sendQ exceeded' disconnection
 ; too low may take the script a long time to update the IAL, 500 or 400 should be fine for most situations
 !return 700
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS LEN.WHO ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
alias -l len.who {
 ; maximum length of the /who <string>, too long may cause the server to ignore the command
 ; too low may slow things down, 400 should be fine in most cases
 !return 400
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS DELAY.WHO ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
alias -l delay.who {
 ; N seconds after the first join, the script starts to update the IAL
 !return 120
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS REPEAT.WHO ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
alias -l repeat.who {
 ; wait N seconds after doing /who to do the next check and /who
 !return 30
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS SHOW ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
alias -l show.who {
 ; set this to 1 if you want the script to echo when the IAL is updated
 ; shows number of opers, number of users that are away, number of users that are deaf (+d),
 ; number of users that have fake host (+x)
 ; may slow things down, needs some checks / loops etc
 ; only shows when a whole channel is being who'd
 !return 1
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; JOIN EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
on *:join:#:{
 ; we join, IAL not updated, timer does not run, start a timer
 if ($nick == $me) && (![[|$timer]]($+($cid,.ial-update.update))) {
   .!timer $+ $cid $+ .ial-update.update 1 $$delay.who ial-update.update
  }
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; LOAD EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
on *:load:{ !scon -at1 .!timer $!+ $!cid $!+ .ial-update.update 1 $$delay.who ial-update.update }
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS IALUPDATE ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
alias ialupdate { !echo -a IAL-update: $ial-update.update }
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS IAL-UPDATE.UPDATE   ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
alias -l ial-update.update {
 !var %c, %n
 ; IAL is set on
 if ($ial) {
   ; hash table does not exist, set a var with the channels we need to who
   if (![[|$hget]]($+(ial-update.,$cid))) { !var %c = [[|$ial-update.chan]]($max.who,$len.who)
     ; something is in there, send it to the hash alias, send the who request
     if (%c) { ial-update.hash %c | .!quote WHO %c }
     ; else no channels to who, set a var with the nicks we need to who
     else { !var %n = [[|$ial-update.nick]]($max.who,$len.who)
       ; something is in there, send it to the hash alias, send the who request
       if (%n) { ial-update.hash %n | .!quote WHO %n  }
     }
   }
   ; we did a who or the hash table was not empty, start a timer to run this alias again
   if (%c) || (%n) || ([[|$hget]]($+(ial-update.,$cid))) {
     .!timer $+ $cid $+ .ial-update.update 1 $$repeat.who ial-update.update
   }
   ; return some info
   if (%c) || (%n) { !return updating }
   elseif ([[|$hget]]($+(ial-update.,$cid))) { !return already in progress }
   else { !return nothing to update }
 }
 ; ial is off return some info
 else { !return ERROR, IAL is turned off, /IAL on to enable }
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS IAL-UPDATE.SORT  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; $ial-update.sort
; sorts channels where the IAL is not updated
; <number of nicks>.<channel number>
; 127.1 <= means 127 users on channel 1
alias -l ial-update.sort {
 !var %x = 1, %c
  ; loop through all common channels that we have with ourself
 ; $chan(0) returns the number of open channel windows,
 ; which does not mean you are on it ("keep channels open" option)
 while (%x <= $comchan($me,0)) {
   ; check if the ial is not updated or busy, add it to a var
   if ($chan($comchan($me,%x)).ial == $false) { !var %c =  $addtok(%c,$+($nick($comchan($me,%x),0),.,%x),32) }
   !inc %x
 }
 ; return it sorted
 !return $sorttok(%c,32,n)
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS IAL-UPDATE.MAX ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; $ial-update.max(N)
; N maximum number of nicks to request at once
; this alias returns the channels to ial based on the info provided by $ial-update.sort
; #chan1,#chan2,#chan3
alias -l ial-update.max {
 !var %x = 1, %t = 0, %c = $ial-update.sort, %w
 ; loop through the channels and as long as %t smaller then $1, increase %t
 while (%x <= $numtok(%c,32)) && (%t < $1) {
   !inc %t $gettok($gettok(%c,%x,32),1,46)
   ; if %t is greater then $1, stop the loop
   if (%t > $1) { !break }
   ; add it to a var
   !var %w = $addtok(%w,$gettok($gettok(%c,%x,32),2,46),32)
   !inc %x
 }
 !return %w
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS IAL-UPDATE.CHAN ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; $ial-update.chan(N,L)
; N maximum number of nicks to request at once
; L maximum length of the WHO request
; this alias is used to WHO channels
alias -l ial-update.chan {
 !var %x = 1, %l = 0, %c = [[|$ial-update.max]]($1), %w
 ; loop through the channels, as long as %l smaller then $2, increase %l for the length of the  channel
 while (%x <= $numtok(%c,32)) && (%l < $2) {
   !inc %l $len($comchan($me,$gettok(%c,%x,32)))
   ; %l greater then $2, stop the loop
   if (%l > $2) { !break }
   ; add it to the var
   !var %w = $addtok(%w,$comchan($me,$gettok(%c,%x,32)),44)
   !inc %x
 }
 !return %w
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS IAL-UPDATE.NICK ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; $ial-update.nick(N,L)
; N maximum number of nicks to request at once
; L maximum length of the WHO request
; this alias is used to WHO nicks
alias -l ial-update.nick {
 !var %x = 1
 ; loop through the channels untill we found one where the IAL isnt updated
 while ($chan($comchan($me,%x)).ial != $false) && (%x <= $comchan($me,0)) {
   !inc %x
 }
 ; ial is not updated, set vars
 if ($chan($comchan($me,%x)).ial == $false) { !var %y = 1, %t = 0, %l = 0, %w
   ; loop
   while (%t <= $1) && (%l < $2) && (%y <= $nick($comchan($me,%x),0)) {
     ; ial for that nick isnt updated, increase %l
     if (!$ial($nick($comchan($me,%x),%y))) {
       !inc %l $len($nick($comchan($me,%x),%y))
       ; if greater then $2, stop the loop
       if (%l > $2) { !break }
       ; add it to the var
       !var %w = $addtok(%w,$nick($comchan($me,%x),%y),44)
     }
     !inc %y
   }
   !return %w
 }
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS IAL-UPDATE.HASH ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; /ial-update.hash <things> -remove
alias -l ial-update.hash {
 ; $2 is not there, set a var
 if ($2 == $null) { !var %x = $numtok($1,44)
   ; loop through each part seperated with a comma, add it to a hash table
   while (%x) { !hadd -m $+(ial-update.,$cid) $gettok($1,%x,44) 1 | !dec %x }
   ; add mask
   !hadd -m $+(ial-update.,$cid) -mask $1
 }
 ; $2 is -remove, set a var
 elseif ($2 == -remove) { !var %x = $numtok($1,44)
   ; loop through each part seperated with a comma, remove it from the hash table
   while (%x) { if ([[|$hget]]($+(ial-update.,$cid))) { !hdel $+(ial-update.,$cid) $gettok($1,%x,44) } | !dec %x }
   ; del mask
   !hdel $+(ial-update.,$cid) -mask
   ; check hash table, free hash table
   if ([[|$hget]]($+(ial-update.,$cid),0).item == 0) && ([[|$hget]]($+(ial-update.,$cid))) { !hfree $+(ial-update.,$cid) }
 }
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; RAW 352 WHO ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; 352 <you> <channel> <user> <host> <server> <nick> <flags> :<distance> <realname>
raw 352:& & & & & & & & *: {
 ; chan or nick are in the hash table
 if ([[|$hget]]($+(ial-update.,$cid),$2)) || ([[|$hget]]($+(ial-update.,$cid),$6)) {
   ; check setting, set a var
   if ($show.who == 1) && ([[|$hget]]($+(ial-update.,$cid),$2)) && ($comchan($6,0)) { !var %x = $comchan($6,0)
     ; loop, set a var
     while (%x) { !var %c = $comchan($6,%x)
       ; check has table
       if ([[|$hget]]($+(ial-update.,$cid),%c)) {
         ; * meaning oper isin $7, increase
         if (* isin $7) { !hinc $+(ial-update.,$cid) $+(%c,$chr(44),oper) }
         ; G meaning Gone isin $7, increase
         if (G isincs $7) { !hinc $+(ial-update.,$cid) $+(%c,$chr(44),away) }
         ; d meaning deaf isin $7, increase
         if (d isincs $7) { !hinc $+(ial-update.,$cid) $+(%c,$chr(44),deaf) }
         ; x meaning fake host isin $7, increase
         if (x isincs $7) { !hinc $+(ial-update.,$cid) $+(%c,$chr(44),xhost) }
       }
       !dec %x
     }
   }
   ; stop mirc from showing this raw
   !haltdef
 }
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; RAW 315 WHO END ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; raw 315 <you> <requested> :End of /who list.
raw 315:& & end of /WHO list.: {
 ; check -mask in hash table
 if ([[|$hget]]($+(ial-update.,$cid),-mask) == $2) {
   ; check setting, set a var
   if ($show.who == 1) { !var %x = $numtok($2,44)
     ; loop, we are on the channel, set var
     while (%x) { if ($me ison $gettok($2,%x,44)) { !var %c = $gettok($2,%x,44)
         ; oper info
         !var %oper = $iif([[|$hget]]($+(ial-update.,$cid),$+(%c,$chr(44),oper)),$ifmatch,0)
         !var %oper = %oper / $round($calc(%oper / $nick(%c,0) * 100),1) $+ % Oper
         ; away info
         !var %away = $iif([[|$hget]]($+(ial-update.,$cid),$+(%c,$chr(44),away)),$ifmatch,0)
         !var %away = %away / $round($calc(%away / $nick(%c,0) * 100),1) $+ % Away
         ; deaf info
         !var %deaf = $iif([[|$hget]]($+(ial-update.,$cid),$+(%c,$chr(44),deaf)),$ifmatch,0)
         !var %deaf = %deaf / $round($calc(%deaf / $nick(%c,0) * 100),1) $+ % deaf
         ; xhost info
         !var %xhost = $iif([[|$hget]]($+(ial-update.,$cid),$+(%c,$chr(44),xhost)),$ifmatch,0)
         !var %xhost = %xhost / $round($calc(%xhost / $nick(%c,0) * 100),1) $+ % x-host
         ; echo
         !echo -t $gettok($2,%x,44) * IAL updated ( $+ %oper ---- %away ---- %deaf ---- %xhost $+ )
       }
       ; remove from hash table
       !hdel $+(ial-update.,$cid) $+(%c,$chr(44),oper) | !hdel $+(ial-update.,$cid) $+(%c,$chr(44),away)
       !hdel $+(ial-update.,$cid) $+(%c,$chr(44),deaf) | !hdel $+(ial-update.,$cid) $+(%c,$chr(44),xhost)
       !dec %x
     }
   }
   ; remove the items from the hash table
   ial-update.hash $2 -remove
   !haltdef
 }
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; DISCONNECT EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
on *:disconnect:{ if ([[|$hget]]($+(ial-update.,$cid))) { !hfree $+(ial-update.,$cid) } }