Difference between revisions of "Test2"

From Scriptwiki
Jump to: navigation, search
m
m (Replaced content with "Test....")
Line 1: Line 1:
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; AUTH_UPDATE ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
Test....
−
;
 
−
;  by Vliedel -- #vliedel @ QuakeNet
 
−
;  version 1.1  (written and tested on mIRC 6.2)
 
−
;  made for networks supporting WHOX
 
−
;
 
−
;
 
−
;What does this script do?
 
−
;
 
−
;  - updastores 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-|$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-|$1]] === QuakeNet) { [[return]] [[$iif]](*.users.quakenet.org iswm [[$1-|$2]],[[$true]]) }
 
−
  [[If-Then-Else|elseif]] ([[$1-|$1]] === UnderNet) { [[return]] [[$iif]](*.users.undernet.org iswm [[$1-|$2]],[[$true]]) }
 
−
  [[If-Then-Else|elseif]] ([[$1-|$1]] === GameSurge) { [[return]] [[$iif]](*.*.GameSurge iswm [[$1-|$2]],[[$true]]) }
 
−
  [[If-Then-Else|elseif]] ([[$1-|$1]] === HanIRC) { [[return]] [[$iif]](*.users.HanIRC.org iswm [[$1-|$2]],[[$true]]) }
 
−
  [[If-Then-Else|elseif]] ([[$1-|$1]] === NetGamers) { [[return]] [[$iif]](*.users.netgamers.org iswm [[$1-|$2]],[[$true]]) }
 
−
  [[If-Then-Else|elseif]] ([[$1-|$1]] === OGameNet) { [[return]] [[$iif]](*.user.OGameNet iswm [[$1-|$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-|$1]] === QuakeNet) { [[return]] [[$gettok]]([[$1-|$2]],1,46) }
 
−
  [[If-Then-Else|elseif]] ([[$1-|$1]] === UnderNet) { [[return]] [[$gettok]]([[$1-|$2]],1,46) }
 
−
  [[If-Then-Else|elseif]] ([[$1-|$1]] === GameSurge) { [[return]] [[$gettok]]([[$1-|$2]],1,46) }
 
−
  [[If-Then-Else|elseif]] ([[$1-|$1]] === HanIRC) { [[return]] [[$gettok]]([[$1-|$2]],1,46) }
 
−
  [[If-Then-Else|elseif]] ([[$1-|$1]] === NetGamers) { [[return]] [[$gettok]]([[$1-|$2]],1,46) }
 
−
  [[If-Then-Else|elseif]] ([[$1-|$1]] === OGameNet) { [[return]] [[$gettok]]([[$1-|$2]],1,46) }
 
−
}
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
[[alias]] auth {
 
−
  [[If-Then-Else|if]] (![[$isid]]) { [[$iif]]([[$show]],.auth,auth) [[$1-|$1-]] | [[return]] }
 
−
  [[If-Then-Else|if]] ([[$1-|$1]] == [[$null]]) || (([[$1-|$2]] !== [[$null]]) && ((![[$scid]]([[$1-|$2]])) || (![[$1-|$2]]))) { [[return]] }
 
−
  [[return]] [[$hget]](auths. [[DollarPlus|$+]] [[$iif]]([[$1-|$2]] !== [[$null]],[[$1-|$2]],[[$cid]]),[[$1-|$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-|$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]] [[DollarPlus|$+]] .auth_update.update)) { auth_update.update n }
 
−
  [[If-Then-Else|else]] {
 
−
    [[Local_Variables|var]] %d = $timer([[$cid]] [[DollarPlus|$+]] .auth_update.update).delay , %l = $timer([[$cid]] [[DollarPlus|$+]] .auth_update.update).secs
 
−
    .[[timer]] [[DollarPlus|$+]] [[$cid]] [[DollarPlus|$+]] .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]] [[DollarPlus|$+]] [[$cid]] [[DollarPlus|$+]] .auth_update.update 1 $delay.who auth_update.update
 
−
  [[If-Then-Else|if]] ([[$hget]](auths. [[DollarPlus|$+]] [[$cid]])) { [[hfree]] $v1 }
 
−
  [[If-Then-Else|if]] ([[$hget]](auths.l. [[DollarPlus|$+]] [[$cid]])) { [[hfree]] $v1 }
 
−
  [[If-Then-Else|if]] ([[$hget]](auths.q. [[DollarPlus|$+]] [[$cid]])) { [[hfree]] $v1 }
 
−
  [[If-Then-Else|if]] ([[$hget]](auths.n. [[DollarPlus|$+]] [[$cid]])) { [[hfree]] $v1 }
 
−
  [[If-Then-Else|if]] ([[$hget]](auths.u. [[DollarPlus|$+]] [[$cid]])) { [[hfree]] $v1 }
 
−
  [[hmake]] auths. [[DollarPlus|$+]] [[$cid]] 200
 
−
  [[hmake]] auths.l. [[DollarPlus|$+]] [[$cid]] 200
 
−
  [[hmake]] auths.q. [[DollarPlus|$+]] [[$cid]] 200
 
−
  [[hmake]] auths.n. [[DollarPlus|$+]] [[$cid]] 100
 
−
  [[Local_Variables|var]] %i = [[$comchan]]([[$me]],0)
 
−
  [[while]] (%i) {
 
−
    [[Local_Variables|var]] %chan = [[$comchan]]([[$me]],%i)
 
−
    [[Local_Variables|var]] %j = [[$nick_(nick)|$nick(]]%chan,0)
 
−
    [[while]] (%j) {
 
−
      auth.l.add.wid [[$chan_(window)|$chan(]]%chan).wid [[$nick_(nick)|$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. [[DollarPlus|$+]] [[$cid]])) {
 
−
    .[[timer]] [[DollarPlus|$+]] [[$cid]] [[DollarPlus|$+]] .auth_update.update off
 
−
    [[hmake]] auths.u. [[DollarPlus|$+]] [[$cid]] 200
 
−
    [[Local_Variables|var]] %who = $auth_update.who
 
−
    [[If-Then-Else|if]] (%who) {
 
−
      [[hadd]] auths.u. [[DollarPlus|$+]] [[$cid]] -mask %who [[DollarPlus|$+]] ,,, [[DollarPlus|$+]] 273
 
−
      .[[timer]] [[DollarPlus|$+]] [[$cid]] [[DollarPlus|$+]] .auth_update.timeout 1 [[$calc]]($repeat.who * 2) auth_update.timeout
 
−
      .quote WHO [[$hget]](auths.u. [[DollarPlus|$+]] [[$cid]],-mask) % [[DollarPlus|$+]] nat,273
 
−
    }
 
−
    [[If-Then-Else|else]] {
 
−
      [[hfree]] auths.u. [[DollarPlus|$+]] [[$cid]]
 
−
      .[[timer]] [[DollarPlus|$+]] [[$cid]] [[DollarPlus|$+]] .auth_update.update 1 $$repeat.who auth_update.update
 
−
    }
 
−
  }
 
−
  [[If-Then-Else|if]] (%who) { [[return]] updating }
 
−
  [[If-Then-Else|elseif]] ([[$hget]](auths.u. [[DollarPlus|$+]] [[$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. [[DollarPlus|$+]] [[$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_(nick)|$nick(]][[$comchan]]([[$me]],%i),0) [[DollarPlus|$+]] . [[DollarPlus|$+]] %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. [[DollarPlus|$+]] [[$cid]] , %t.l = auths.l. [[DollarPlus|$+]] [[$cid]] , %t.q = auths.q. [[DollarPlus|$+]] [[$cid]] , %t.n = auths.n. [[DollarPlus|$+]] [[$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_(window)|$chan(]]%chan).wid [[DollarPlus|$+]] .
 
−
    [[Local_Variables|var]] %n.c = [[$nick_(nick)|$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 [[DollarPlus|$+]] -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 [[DollarPlus|$+]] %n),2,32)
 
−
    }
 
−
    [[Local_Variables|var]] %n = [[$hget]](%t.l,%id [[DollarPlus|$+]] -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 [[DollarPlus|$+]] %n),2,32)
 
−
    }
 
−
    [[Local_Variables|var]] %n = [[$hget]](%t.q,%id [[DollarPlus|$+]] -firstnick)
 
−
    [[while]] (%n) {
 
−
      [[tokenize]] 32 [[$hget]](%t.q,%id [[DollarPlus|$+]] %n)
 
−
      [[If-Then-Else|if]] ([[$1-|$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 = [[$1-|$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_(nick)|$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_(nick)|$nick(]]%chan,0)
 
−
    [[while]] (%j) {
 
−
      [[Local_Variables|var]] %n = [[$nick_(nick)|$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_(nick)|$nick(]]%chan,0) > %n.max) || (![[$istok]](%chans.go,%i,32))) {
 
−
      [[Local_Variables|var]] %id = [[$chan_(window)|$chan(]]%chan).wid [[DollarPlus|$+]] . , %n = [[$hget]](%t.l,%id [[DollarPlus|$+]] -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 [[DollarPlus|$+]] %n),2,32)
 
−
      }
 
−
      [[If-Then-Else|if]] (%n.nr > %n.max) || (%len > %l.max) { [[break]] }
 
−
      [[Local_Variables|var]] %n = [[$hget]](%t.q,%id [[DollarPlus|$+]] -firstnick)
 
−
      [[while]] (%n) {
 
−
        [[tokenize]] 32 [[$hget]](%t.q,%id [[DollarPlus|$+]] %n)
 
−
        [[If-Then-Else|if]] ([[$1-|$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 = [[$1-|$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]]([[$1-|$3]],1)) { auth_update.nick [[$1-|$3]] [[$1-|$4]] }
 
−
  [[If-Then-Else|elseif]] ([[$hget]](auths.n. [[DollarPlus|$+]] [[$cid]],[[$1-|$3]])) { auth.n.rem [[$1-|$3]] | .[[signal]] authupdate [[$1-|$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. [[DollarPlus|$+]] [[$cid]],-mask) == [[$1-|$2]]) {
 
−
    [[hfree]] auths.u. [[DollarPlus|$+]] [[$cid]]
 
−
    .[[timer]] [[DollarPlus|$+]] [[$cid]] [[DollarPlus|$+]] .auth_update.timeout off
 
−
    .[[timer]] [[DollarPlus|$+]] [[$cid]] [[DollarPlus|$+]] .auth_update.update 1 [[$iif]]([[$hget]](auths.n. [[DollarPlus|$+]] [[$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. [[DollarPlus|$+]] [[$cid]],[[$1-|$1]]) != [[$1-|$2]]) {
 
−
    .[[signal]] authupdate.new [[$1-|$1]] [[$1-|$2]]
 
−
    auth.add [[$1-|$1]] [[$1-|$2]]
 
−
  }
 
−
  auth.l.rem [[$1-|$1]]
 
−
  [[If-Then-Else|if]] ([[$1-|$2]] == 0) { auth.q.add [[$1-|$1]] }
 
−
  [[If-Then-Else|else]] { auth.q.rem [[$1-|$1]] }
 
−
  [[If-Then-Else|if]] ([[$hget]](auths.n. [[DollarPlus|$+]] [[$cid]],[[$1-|$1]])) { auth.n.rem [[$1-|$1]] | .[[signal]] authupdate [[$1-|$1]] [[$1-|$2]] }
 
−
}
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; JOIN EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
on *:JOIN:#:{
 
−
  [[If-Then-Else|if]] ([[$nick_(remote)|$nick]] == [[$me]]) && ($used.network([[$network]])) {
 
−
    [[If-Then-Else|if]] (![[$hget]](auths. [[DollarPlus|$+]] [[$cid]])) { [[hmake]] auths. [[DollarPlus|$+]] [[$cid]] 200 }
 
−
    [[If-Then-Else|if]] (![[$hget]](auths.l. [[DollarPlus|$+]] [[$cid]])) { [[hmake]] auths.l. [[DollarPlus|$+]] [[$cid]] 200 }
 
−
    [[If-Then-Else|if]] (![[$hget]](auths.q. [[DollarPlus|$+]] [[$cid]])) { [[hmake]] auths.q. [[DollarPlus|$+]] [[$cid]] 200 }
 
−
    [[If-Then-Else|if]] (![[$hget]](auths.n. [[DollarPlus|$+]] [[$cid]])) { [[hmake]] auths.n. [[DollarPlus|$+]] [[$cid]] 100 }
 
−
    [[If-Then-Else|if]] (!$timer([[$cid]] [[DollarPlus|$+]] .auth_update.update)) { .[[timer]] [[DollarPlus|$+]] [[$cid]] [[DollarPlus|$+]] .auth_update.update 1 $delay.who auth_update.update }
 
−
    [[return]]
 
−
  }
 
−
  [[If-Then-Else|if]] ($auth.site([[$network]],$site)) { auth_update.nick [[$nick_(remote)|$nick]] $auth.from.site([[$network]],$site) | [[return]] }
 
−
  [[If-Then-Else|if]] ([[$hget]](auths. [[DollarPlus|$+]] [[$cid]],[[$nick_(remote)|$nick]]) == [[$null]]) { auth.l.add.wid [[$chan_(window)|$chan(]][[$chan_(remote)|$chan]]).wid [[$nick_(remote)|$nick]] }
 
−
  [[If-Then-Else|elseif]] ([[$hget]](auths. [[DollarPlus|$+]] [[$cid]],[[$nick_(remote)|$nick]]) == 0) {
 
−
    auth.q.add.wid [[$chan_(window)|$chan(]][[$chan_(remote)|$chan]]).wid [[$nick_(remote)|$nick]]
 
−
    [[If-Then-Else|if]] (![[$comchan]]([[$nick_(remote)|$nick]],2)) { auth.q.add.main [[$nick_(remote)|$nick]] }
 
−
  }
 
−
  [[If-Then-Else|if]] ([[$hget]](auths.n. [[DollarPlus|$+]] [[$cid]],[[$nick_(remote)|$nick]])) { auth.n.add.wid [[$chan_(window)|$chan(]][[$1-|$2]]).wid [[$nick_(remote)|$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_(nick)|$nick(]][[$1-|$2]],0) , %t = auths. [[DollarPlus|$+]] [[$cid]]
 
−
  [[while]] (%i) {
 
−
    [[Local_Variables|var]] %n = [[$nick_(nick)|$nick(]][[$1-|$2]],%i)
 
−
    [[If-Then-Else|if]] ([[$hget]](%t,%n) == [[$null]]) { auth.l.add.wid [[$chan_(window)|$chan(]][[$1-|$2]]).wid %n }
 
−
    [[If-Then-Else|elseif]] ([[$hget]](%t,%n) == 0) {
 
−
      auth.q.add.wid [[$chan_(window)|$chan(]][[$1-|$2]]).wid %n
 
−
      [[If-Then-Else|if]] (![[$comchan]](%n,2)) { auth.q.add.main %n }
 
−
    }
 
−
    [[If-Then-Else|if]] ([[$hget]](auths.n. [[DollarPlus|$+]] [[$cid]],%n)) { auth.n.add.wid [[$chan_(window)|$chan(]][[$1-|$2]]).wid %n }
 
−
    [[dec]] %i
 
−
  }
 
−
}
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; PART EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
on *:PART:#:{
 
−
  [[If-Then-Else|if]] ([[$nick_(remote)|$nick]] == [[$me]]) {
 
−
    auth.rem.chan [[$chan_(remote)|$chan]]
 
−
    auth.l.rem.chan.all [[$chan_(remote)|$chan]]
 
−
    auth.q.rem.chan.all [[$chan_(remote)|$chan]]
 
−
    auth.n.rem.chan.all [[$chan_(remote)|$chan]]
 
−
  }
 
−
  [[If-Then-Else|else]] {
 
−
    auth.l.rem.wid [[$chan_(window)|$chan(]][[$chan_(remote)|$chan]]).wid [[$nick_(remote)|$nick]]
 
−
    auth.q.rem.wid [[$chan_(window)|$chan(]][[$chan_(remote)|$chan]]).wid [[$nick_(remote)|$nick]]
 
−
    auth.n.rem.wid [[$chan_(window)|$chan(]][[$chan_(remote)|$chan]]).wid [[$nick_(remote)|$nick]]
 
−
    [[If-Then-Else|if]] (![[$comchan]]([[$nick_(remote)|$nick]],2)) {
 
−
      auth.rem [[$nick_(remote)|$nick]]
 
−
      auth.q.rem.main [[$nick_(remote)|$nick]]
 
−
      auth.n.rem.main [[$nick_(remote)|$nick]]
 
−
    }
 
−
    [[If-Then-Else|elseif]] ($auth.site([[$network]],$site)) { auth_update.nick [[$nick_(remote)|$nick]] $auth.from.site([[$network]],$site) }
 
−
  }
 
−
}
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; KICK EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
on *:KICK:#:{
 
−
  [[If-Then-Else|if]] ($knick == [[$me]]) {
 
−
    auth.rem.chan [[$chan_(remote)|$chan]]
 
−
    auth.l.rem.chan.all [[$chan_(remote)|$chan]]
 
−
    auth.q.rem.chan.all [[$chan_(remote)|$chan]]
 
−
    auth.n.rem.chan.all [[$chan_(remote)|$chan]]
 
−
  }
 
−
  [[If-Then-Else|else]] {
 
−
    auth.l.rem.wid [[$chan_(window)|$chan(]][[$chan_(remote)|$chan]]).wid $knick
 
−
    auth.q.rem.wid [[$chan_(window)|$chan(]][[$chan_(remote)|$chan]]).wid $knick
 
−
    auth.n.rem.wid [[$chan_(window)|$chan(]][[$chan_(remote)|$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_(remote)|$nick]],1)) { auth_update.nick [[$nick_(remote)|$nick]] $auth.from.site([[$network]],$site) }
 
−
  }
 
−
}
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; QUIT EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
on *:QUIT:{
 
−
  auth.rem [[$nick_(remote)|$nick]]
 
−
  auth.l.rem [[$nick_(remote)|$nick]]
 
−
  auth.q.rem [[$nick_(remote)|$nick]]
 
−
  auth.n.rem [[$nick_(remote)|$nick]]
 
−
}
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; NICK EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
on *:NICK:{
 
−
  auth.nick [[$nick_(remote)|$nick]] $newnick
 
−
  auth.l.nick [[$nick_(remote)|$nick]] $newnick
 
−
  auth.q.nick [[$nick_(remote)|$nick]] $newnick
 
−
  auth.n.nick [[$nick_(remote)|$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_(remote)|$nick]],1)) { auth_update.nick [[$nick_(remote)|$nick]] $auth.from.site([[$network]],$site) } }
 
−
on *:ACTION:*:*:{ [[If-Then-Else|if]] ($auth.site([[$network]],$site)) && ([[$comchan]]([[$nick_(remote)|$nick]],1)) { auth_update.nick [[$nick_(remote)|$nick]] $auth.from.site([[$network]],$site) } }
 
−
on *:NOTICE:*:*:{ [[If-Then-Else|if]] ($auth.site([[$network]],$site)) && ([[$comchan]]([[$nick_(remote)|$nick]],1)) { auth_update.nick [[$nick_(remote)|$nick]] $auth.from.site([[$network]],$site) } }
 
−
on *:RAWMODE:#:{ [[If-Then-Else|if]] ($auth.site([[$network]],$site)) && ([[$comchan]]([[$nick_(remote)|$nick]],1)) { auth_update.nick [[$nick_(remote)|$nick]] $auth.from.site([[$network]],$site) } }
 
−
on *:TOPIC:#:{ [[If-Then-Else|if]] ($auth.site([[$network]],$site)) && ([[$comchan]]([[$nick_(remote)|$nick]],1)) { auth_update.nick [[$nick_(remote)|$nick]] $auth.from.site([[$network]],$site) } }
 
−
on *:INVITE:#:{ [[If-Then-Else|if]] ($auth.site([[$network]],$site)) && ([[$comchan]]([[$nick_(remote)|$nick]],1)) { auth_update.nick [[$nick_(remote)|$nick]] $auth.from.site([[$network]],$site) } }
 
−
[[CTCP]] *:*:*:{ [[If-Then-Else|if]] ($auth.site([[$network]],$site)) && ([[$comchan]]([[$nick_(remote)|$nick]],1)) { auth_update.nick [[$nick_(remote)|$nick]] $auth.from.site([[$network]],$site) } }
 
−
RAW 352:& & & & & & & & *: { [[If-Then-Else|if]] ($auth.site([[$network]],[[$1-|$4]])) && ([[$comchan]]([[$1-|$6]],1)) { auth_update.nick [[$1-|$6]] $auth.from.site([[$network]],[[$1-|$4]]) } }
 
−
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; DISCONNECT EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
on *:DISCONNECT:{
 
−
  [[If-Then-Else|if]] ([[$hget]](auths.u [[DollarPlus|$+]] [[$cid]])) { [[hfree]] $v1 }
 
−
  [[If-Then-Else|if]] ([[$hget]](auths. [[DollarPlus|$+]] [[$cid]])) { [[hfree]] $v1 }
 
−
  [[If-Then-Else|if]] ([[$hget]](auths.q. [[DollarPlus|$+]] [[$cid]])) { [[hfree]] $v1 }
 
−
  [[If-Then-Else|if]] ([[$hget]](auths.l. [[DollarPlus|$+]] [[$cid]])) { [[hfree]] $v1 }
 
−
  [[If-Then-Else|if]] ([[$hget]](auths.n. [[DollarPlus|$+]] [[$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. [[DollarPlus|$+]] [[$cid]])) { [[return]] }
 
−
  [[hadd]] auths. [[DollarPlus|$+]] [[$cid]] [[$1-|$1]] [[$1-|$2]]
 
−
}
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.REM ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
; $1 = nick
 
−
[[alias]] -l auth.rem {
 
−
  [[If-Then-Else|if]] (![[$hget]](auths. [[DollarPlus|$+]] [[$cid]])) { [[return]] }
 
−
  [[hdel]] auths. [[DollarPlus|$+]] [[$cid]] [[$1-|$1]]
 
−
}
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.REM.CHAN ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
; $1 = chan
 
−
[[alias]] -l auth.rem.chan {
 
−
  [[If-Then-Else|if]] (![[$hget]](auths. [[DollarPlus|$+]] [[$cid]])) { [[return]] }
 
−
  [[Local_Variables|var]] %i = [[$nick_(nick)|$nick(]][[$1-|$1]],0)
 
−
  [[while]] (%i) {
 
−
    [[If-Then-Else|if]] (![[$comchan]]([[$nick_(nick)|$nick(]][[$1-|$1]],%i),2)) { [[hdel]] auths. [[DollarPlus|$+]] [[$cid]] [[$nick_(nick)|$nick(]][[$1-|$1]],%i) }
 
−
    [[dec]] %i
 
−
  }
 
−
}
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.NICK ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
; $1 = nick  $2 = newnick
 
−
[[alias]] -l auth.nick {
 
−
  [[If-Then-Else|if]] ([[$hget]](auths. [[DollarPlus|$+]] [[$cid]],[[$1-|$1]]) !== [[$null]]) { [[hdel]] auths. [[DollarPlus|$+]] [[$cid]] [[$1-|$1]] | [[hadd]] auths. [[DollarPlus|$+]] [[$cid]] [[$1-|$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. [[DollarPlus|$+]] [[$cid]]
 
−
  [[If-Then-Else|if]] (![[$hget]](%table)) { [[return]] }
 
−
  [[Local_Variables|var]] %id = [[$1-|$1]] [[DollarPlus|$+]] . ,  %lastnick = [[$hget]](%table,%id [[DollarPlus|$+]] -lastnick)
 
−
  [[If-Then-Else|if]] ([[$hget]](%table,%id [[DollarPlus|$+]] [[$1-|$2]])) { [[return]] }
 
−
  [[If-Then-Else|if]] (%lastnick) {
 
−
    [[hadd]] %table %id [[DollarPlus|$+]] [[$1-|$2]] %lastnick 0
 
−
    [[hadd]] %table %id [[DollarPlus|$+]] %lastnick [[$gettok]]([[$hget]](%table,%id [[DollarPlus|$+]] %lastnick),1,32) [[$1-|$2]]
 
−
  }
 
−
  [[If-Then-Else|else]] {
 
−
    [[hadd]] %table %id [[DollarPlus|$+]] [[$1-|$2]] 0 0
 
−
    [[hadd]] %table %id [[DollarPlus|$+]] -firstnick [[$1-|$2]]
 
−
  }
 
−
  [[hadd]] %table %id [[DollarPlus|$+]] -lastnick [[$1-|$2]]
 
−
}
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.L.REM ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
; $1 = nick
 
−
[[alias]] -l auth.l.rem {
 
−
  [[If-Then-Else|if]] (![[$hget]](auths.l. [[DollarPlus|$+]] [[$cid]])) { [[return]] }
 
−
  [[Local_Variables|var]] %i = [[$comchan]]([[$1-|$1]],0)
 
−
  [[while]] (%i) {
 
−
    auth.l.rem.wid [[$chan_(window)|$chan(]][[$comchan]]([[$1-|$1]],%i)).wid [[$1-|$1]]
 
−
    [[dec]] %i
 
−
  }
 
−
}
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.L.REM.WID ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
; $1 = wid  $2 = nick
 
−
[[alias]] -l auth.l.rem.wid {
 
−
  [[Local_Variables|var]] %table = auths.l. [[DollarPlus|$+]] [[$cid]]
 
−
  [[If-Then-Else|if]] (![[$hget]](%table)) { [[return]] }
 
−
  [[Local_Variables|var]] %id = [[$1-|$1]] [[DollarPlus|$+]] . , %val = [[$hget]](%table,%id [[DollarPlus|$+]] [[$1-|$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 [[DollarPlus|$+]] [[$1-|$2]]
 
−
  [[If-Then-Else|if]] (%nick.l == 0) && (%nick.r == 0) { [[hdel]] %table %id [[DollarPlus|$+]] -lastnick | [[hdel]] %table %id [[DollarPlus|$+]] -firstnick | [[return]] }
 
−
  [[If-Then-Else|if]] (%nick.l !== 0) { [[hadd]] %table %id [[DollarPlus|$+]] %nick.l [[$gettok]]([[$hget]](%table,%id [[DollarPlus|$+]] %nick.l),1,32) %nick.r }
 
−
  [[If-Then-Else|else]] { [[hadd]] %table %id [[DollarPlus|$+]] -firstnick %nick.r }
 
−
  [[If-Then-Else|if]] (%nick.r !== 0) { [[hadd]] %table %id [[DollarPlus|$+]] %nick.r %nick.l [[$gettok]]([[$hget]](%table,%id [[DollarPlus|$+]] %nick.r),2,32) }
 
−
  [[If-Then-Else|else]] { [[hadd]] %table %id [[DollarPlus|$+]] -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. [[DollarPlus|$+]] [[$cid]])) { [[return]] }
 
−
  [[hdel]] -w auths.l. [[DollarPlus|$+]] [[$cid]] [[$chan_(window)|$chan(]][[$1-|$1]]).wid [[DollarPlus|$+]] .*
 
−
}
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.L.NICK ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
; $1 = nick  $2 = newnick
 
−
[[alias]] -l auth.l.nick {
 
−
  [[If-Then-Else|if]] ([[$1-|$1]] == [[$1-|$2]]) { [[return]] }
 
−
  [[Local_Variables|var]] %table = auths.l. [[DollarPlus|$+]] [[$cid]]
 
−
  [[If-Then-Else|if]] (![[$hget]](%table)) { [[return]] }
 
−
  [[Local_Variables|var]] %i = [[$comchan]]([[$1-|$2]],0)
 
−
  [[while]] (%i) {
 
−
    [[Local_Variables|var]] %id = [[$chan_(window)|$chan(]][[$comchan]]([[$1-|$2]],%i)).wid [[DollarPlus|$+]] . , %val = [[$hget]](%table,%id [[DollarPlus|$+]] [[$1-|$1]])
 
−
    [[If-Then-Else|if]] (%val) {
 
−
      [[hdel]] %table %id [[DollarPlus|$+]] [[$1-|$1]]
 
−
      [[hadd]] %table %id [[DollarPlus|$+]] [[$1-|$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 [[DollarPlus|$+]] %nick.l [[$gettok]]([[$hget]](%table,%id [[DollarPlus|$+]] %nick.l),1,32) [[$1-|$2]] }
 
−
      [[If-Then-Else|else]] { [[hadd]] %table %id [[DollarPlus|$+]] -firstnick [[$1-|$2]] }
 
−
      [[If-Then-Else|if]] (%nick.r !== 0) { [[hadd]] %table %id [[DollarPlus|$+]] %nick.r [[$1-|$2]] [[$gettok]]([[$hget]](%table,%id [[DollarPlus|$+]] %nick.r),2,32) }
 
−
      [[If-Then-Else|else]] { [[hadd]] %table %id [[DollarPlus|$+]] -lastnick [[$1-|$2]] }
 
−
    }
 
−
    [[dec]] %i
 
−
  }
 
−
}
 
−
 
−
 
−
 
−
; -----------------------------------------------------------------------------------------------------
 
−
; --------------------------------------- AUTHS - QUEUE - TABLE ---------------------------------------
 
−
; -----------------------------------------------------------------------------------------------------
 
−
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.Q.ADD ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
; $1 = nick
 
−
[[alias]] -l auth.q.add {
 
−
  [[If-Then-Else|if]] (![[$hget]](auths.q. [[DollarPlus|$+]] [[$cid]])) { [[return]] }
 
−
  auth.q.add.main [[$1-|$1]]
 
−
  [[Local_Variables|var]] %i = [[$comchan]]([[$1-|$1]],0)
 
−
  [[while]] (%i) {
 
−
    auth.q.add.wid [[$chan_(window)|$chan(]][[$comchan]]([[$1-|$1]],%i)).wid [[$1-|$1]]
 
−
    [[dec]] %i
 
−
  }
 
−
}
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.Q.ADD.WID ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
; $1 = wid  $2 = nick
 
−
[[alias]] -l auth.q.add.wid {
 
−
  [[Local_Variables|var]] %table = auths.q. [[DollarPlus|$+]] [[$cid]]
 
−
  [[If-Then-Else|if]] (![[$hget]](%table)) { [[return]] }
 
−
  [[Local_Variables|var]] %id = [[$1-|$1]] [[DollarPlus|$+]] . , %ctime = [[$iif]]([[$hget]](%table,[[$1-|$2]]) == [[$null]],[[$ctime]],$v1)
 
−
  auth.q.rem.wid [[$1-|$1]] [[$1-|$2]]
 
−
  [[Local_Variables|var]] %lastnick = [[$hget]](%table,%id [[DollarPlus|$+]] -lastnick)
 
−
  [[If-Then-Else|if]] (!%lastnick) {
 
−
    [[hadd]] %table %id [[DollarPlus|$+]] [[$1-|$2]] %ctime 0 0
 
−
    [[hadd]] %table %id [[DollarPlus|$+]] -firstnick [[$1-|$2]]
 
−
    [[hadd]] %table %id [[DollarPlus|$+]] -lastnick [[$1-|$2]]
 
−
    [[return]]
 
−
  }
 
−
  [[If-Then-Else|if]] (%ctime >= [[$hget]](%table,%lastnick)) {
 
−
    [[hadd]] %table %id [[DollarPlus|$+]] [[$1-|$2]] %ctime %lastnick 0
 
−
    [[hadd]] %table %id [[DollarPlus|$+]] %lastnick [[$gettok]]([[$hget]](%table,%id [[DollarPlus|$+]] %lastnick),1-2,32) [[$1-|$2]]
 
−
    [[hadd]] %table %id [[DollarPlus|$+]] -lastnick [[$1-|$2]]
 
−
    [[return]]
 
−
  }
 
−
  [[Local_Variables|var]] %n = [[$hget]](%table,%id [[DollarPlus|$+]] -firstnick) , %nick = [[$1-|$2]]
 
−
  [[while]] (%n) {
 
−
    [[tokenize]] 32 [[$hget]](%table,%id [[DollarPlus|$+]] %n)
 
−
    [[If-Then-Else|if]] (%ctime <= [[$1-|$1]]) {
 
−
      [[hadd]] %table %id [[DollarPlus|$+]] %n [[$1-|$1]] %nick [[$1-|$3]]
 
−
      [[If-Then-Else|if]] ([[$1-|$2]] == 0) {
 
−
        [[hadd]] %table %id [[DollarPlus|$+]] %nick %ctime 0 %n
 
−
        [[hadd]] %table %id [[DollarPlus|$+]] -firstnick %nick
 
−
      }
 
−
      [[If-Then-Else|else]] {
 
−
        [[hadd]] %table %id [[DollarPlus|$+]] %nick %ctime [[$1-|$2]] %n
 
−
        [[hadd]] %table %id [[DollarPlus|$+]] [[$1-|$2]] [[$gettok]]([[$hget]](%table,%id [[DollarPlus|$+]] [[$1-|$2]]),1-2,32) %nick
 
−
      }
 
−
      [[break]]
 
−
    }
 
−
    [[Local_Variables|var]] %n = [[$1-|$3]]
 
−
  }
 
−
}
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.Q.ADD.MAIN ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
; $1 = nick
 
−
[[alias]] -l auth.q.add.main {
 
−
  [[If-Then-Else|if]] (![[$hget]](auths.q. [[DollarPlus|$+]] [[$cid]])) { [[return]] }
 
−
  [[hadd]] auths.q. [[DollarPlus|$+]] [[$cid]] [[$1-|$1]] [[$ctime]]
 
−
}
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.Q.REM ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
; $1 = nick
 
−
[[alias]] -l auth.q.rem {
 
−
  [[If-Then-Else|if]] (![[$hget]](auths.q. [[DollarPlus|$+]] [[$cid]])) { [[return]] }
 
−
  [[Local_Variables|var]] %i = [[$comchan]]([[$1-|$1]],0)
 
−
  [[while]] (%i) {
 
−
    auth.q.rem.wid [[$chan_(window)|$chan(]][[$comchan]]([[$1-|$1]],%i)).wid [[$1-|$1]]
 
−
    [[dec]] %i
 
−
  }
 
−
  auth.q.rem.main [[$1-|$1]]
 
−
}
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.Q.REM.WID ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
; $1 = wid  $2 = nick
 
−
[[alias]] -l auth.q.rem.wid {
 
−
  [[Local_Variables|var]] %table = auths.q. [[DollarPlus|$+]] [[$cid]]
 
−
  [[If-Then-Else|if]] (![[$hget]](%table)) { [[return]] }
 
−
  [[Local_Variables|var]] %id = [[$1-|$1]] [[DollarPlus|$+]] . , %val = [[$hget]](%table,%id [[DollarPlus|$+]] [[$1-|$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 [[DollarPlus|$+]] [[$1-|$2]]
 
−
  [[If-Then-Else|if]] (%nick.l == 0) && (%nick.r == 0) { [[hdel]] %table %id [[DollarPlus|$+]] -lastnick | [[hdel]] %table %id [[DollarPlus|$+]] -firstnick | [[return]] }
 
−
  [[If-Then-Else|if]] (%nick.l !== 0) { [[hadd]] %table %id [[DollarPlus|$+]] %nick.l [[$gettok]]([[$hget]](%table,%id [[DollarPlus|$+]] %nick.l),1-2,32) %nick.r }
 
−
  [[If-Then-Else|else]] { [[hadd]] %table %id [[DollarPlus|$+]] -firstnick %nick.r }
 
−
  [[If-Then-Else|if]] (%nick.r !== 0) { [[hadd]] %table %id [[DollarPlus|$+]] %nick.r [[$gettok]]([[$hget]](%table,%id [[DollarPlus|$+]] %nick.r),1,32) %nick.l [[$gettok]]([[$hget]](%table,%id [[DollarPlus|$+]] %nick.r),3,32) }
 
−
  [[If-Then-Else|else]] { [[hadd]] %table %id [[DollarPlus|$+]] -lastnick %nick.l }
 
−
}
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.Q.REM.MAIN ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
; $1 = nick
 
−
[[alias]] -l auth.q.rem.main {
 
−
  [[If-Then-Else|if]] (![[$hget]](auths.q. [[DollarPlus|$+]] [[$cid]])) { [[return]] }
 
−
  [[hdel]] auths.q. [[DollarPlus|$+]] [[$cid]] [[$1-|$1]]
 
−
}
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.Q.REM.CHAN.ALL ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
; $1 = chan
 
−
[[alias]] -l auth.q.rem.chan.all {
 
−
  [[Local_Variables|var]] %table = auths.q. [[DollarPlus|$+]] [[$cid]]
 
−
  [[If-Then-Else|if]] (![[$hget]](%table)) { [[return]] }
 
−
  [[hdel]] -w %table [[$chan_(window)|$chan(]][[$1-|$1]]).wid [[DollarPlus|$+]] .*
 
−
  [[Local_Variables|var]] %i = [[$nick_(nick)|$nick(]][[$1-|$1]],0)
 
−
  [[while]] (%i) {
 
−
    [[If-Then-Else|if]] (![[$comchan]]([[$nick_(nick)|$nick(]][[$1-|$1]],%i),2)) { [[hdel]] %table [[$nick_(nick)|$nick(]][[$1-|$1]],%i) }
 
−
    [[dec]] %i
 
−
  }
 
−
}
 
−
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.Q.NICK ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
; $1 = nick  $2 = newnick
 
−
[[alias]] -l auth.q.nick {
 
−
  [[If-Then-Else|if]] ([[$1-|$1]] == [[$1-|$2]]) { [[return]] }
 
−
  [[Local_Variables|var]] %table = auths.q. [[DollarPlus|$+]] [[$cid]]
 
−
  [[If-Then-Else|if]] (![[$hget]](%table)) { [[return]] }
 
−
  [[Local_Variables|var]] %i = [[$comchan]]([[$1-|$2]],0)
 
−
  [[while]] (%i) {
 
−
    [[Local_Variables|var]] %id = [[$chan_(window)|$chan(]][[$comchan]]([[$1-|$2]],%i)).wid [[DollarPlus|$+]] . , %val = [[$hget]](%table,%id [[DollarPlus|$+]] [[$1-|$1]])
 
−
    [[If-Then-Else|if]] (%val) {
 
−
      [[hdel]] %table %id [[DollarPlus|$+]] [[$1-|$1]]
 
−
      [[hadd]] %table %id [[DollarPlus|$+]] [[$1-|$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 [[DollarPlus|$+]] %nick.l [[$gettok]]([[$hget]](%table,%id [[DollarPlus|$+]] %nick.l),1-2,32) [[$1-|$2]] }
 
−
      [[If-Then-Else|else]] { [[hadd]] %table %id [[DollarPlus|$+]] -firstnick [[$1-|$2]] }
 
−
      [[If-Then-Else|if]] (%nick.r !== 0) { [[hadd]] %table %id [[DollarPlus|$+]] %nick.r [[$gettok]]([[$hget]](%table,%id [[DollarPlus|$+]] %nick.r),1,32) [[$1-|$2]] [[$gettok]]([[$hget]](%table,%id [[DollarPlus|$+]] %nick.r),3,32) }
 
−
      [[If-Then-Else|else]] { [[hadd]] %table %id [[DollarPlus|$+]] -lastnick [[$1-|$2]] }
 
−
    }
 
−
    [[dec]] %i
 
−
  }
 
−
  [[If-Then-Else|if]] ([[$hget]](%table,[[$1-|$1]]) !== [[$null]]) { [[hdel]] %table [[$1-|$1]] | [[hadd]] %table [[$1-|$2]] $v1 }
 
−
}
 
−
 
−
 
−
 
−
; ----------------------------------------------------------------------------------------------------
 
−
; --------------------------------------- AUTHS - NEXT - TABLE ---------------------------------------
 
−
; ----------------------------------------------------------------------------------------------------
 
−
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.N.ADD ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
; $1 = nick
 
−
[[alias]] -l auth.n.add {
 
−
  [[If-Then-Else|if]] (![[$hget]](auths.n. [[DollarPlus|$+]] [[$cid]])) { [[return]] }
 
−
  auth.n.add.main [[$1-|$1]]
 
−
  [[Local_Variables|var]] %i = [[$comchan]]([[$1-|$1]],0)
 
−
  [[while]] (%i) {
 
−
    auth.n.add.wid [[$chan_(window)|$chan(]][[$comchan]]([[$1-|$1]],%i)).wid [[$1-|$1]]
 
−
    [[dec]] %i
 
−
  }
 
−
}
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.N.ADD.WID ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
; $1 = wid  $2 = nick
 
−
[[alias]] -l auth.n.add.wid {
 
−
  [[Local_Variables|var]] %table = auths.n. [[DollarPlus|$+]] [[$cid]]
 
−
  [[If-Then-Else|if]] (![[$hget]](%table)) { [[return]] }
 
−
  [[Local_Variables|var]] %id = [[$1-|$1]] [[DollarPlus|$+]] . ,  %lastnick = [[$hget]](%table,%id [[DollarPlus|$+]] -lastnick)
 
−
  [[If-Then-Else|if]] ([[$hget]](%table,%id [[DollarPlus|$+]] [[$1-|$2]])) { [[return]] }
 
−
  [[If-Then-Else|if]] (%lastnick) {
 
−
    [[hadd]] %table %id [[DollarPlus|$+]] [[$1-|$2]] %lastnick 0
 
−
    [[hadd]] %table %id [[DollarPlus|$+]] %lastnick [[$gettok]]([[$hget]](%table,%id [[DollarPlus|$+]] %lastnick),1,32) [[$1-|$2]]
 
−
  }
 
−
  [[If-Then-Else|else]] {
 
−
    [[hadd]] %table %id [[DollarPlus|$+]] [[$1-|$2]] 0 0
 
−
    [[hadd]] %table %id [[DollarPlus|$+]] -firstnick [[$1-|$2]]
 
−
  }
 
−
  [[hadd]] %table %id [[DollarPlus|$+]] -lastnick [[$1-|$2]]
 
−
}
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.N.ADD.MAIN ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
; $1 = nick
 
−
[[alias]] -l auth.n.add.main {
 
−
  [[Local_Variables|var]] %table = auths.n. [[DollarPlus|$+]] [[$cid]]
 
−
  [[If-Then-Else|if]] (![[$hget]](%table)) { [[return]] }
 
−
  [[Local_Variables|var]] %lastnick = [[$hget]](%table,-lastnick)
 
−
  [[If-Then-Else|if]] ([[$hget]](%table,[[$1-|$1]])) { [[return]] }
 
−
  [[If-Then-Else|if]] (%lastnick) {
 
−
    [[hadd]] %table [[$1-|$1]] %lastnick 0
 
−
    [[hadd]] %table %lastnick [[$gettok]]([[$hget]](%table,%lastnick),1,32) [[$1-|$1]]
 
−
  }
 
−
  [[If-Then-Else|else]] {
 
−
    [[hadd]] %table [[$1-|$1]] 0 0
 
−
    [[hadd]] %table -firstnick [[$1-|$1]]
 
−
  }
 
−
  [[hadd]] %table -lastnick [[$1-|$1]]
 
−
}
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.N.REM ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
; $1 = nick
 
−
[[alias]] -l auth.n.rem {
 
−
  [[If-Then-Else|if]] (![[$hget]](auths.n. [[DollarPlus|$+]] [[$cid]])) { [[return]] }
 
−
  [[Local_Variables|var]] %i = [[$comchan]]([[$1-|$1]],0)
 
−
  [[while]] (%i) {
 
−
    auth.n.rem.wid [[$chan_(window)|$chan(]][[$comchan]]([[$1-|$1]],%i)).wid [[$1-|$1]]
 
−
    [[dec]] %i
 
−
  }
 
−
  auth.n.rem.main [[$1-|$1]]
 
−
}
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.N.REM.WID ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
; $1 = wid  $2 = nick
 
−
[[alias]] -l auth.n.rem.wid {
 
−
  [[Local_Variables|var]] %table = auths.n. [[DollarPlus|$+]] [[$cid]]
 
−
  [[If-Then-Else|if]] (![[$hget]](%table)) { [[return]] }
 
−
  [[Local_Variables|var]] %id = [[$1-|$1]] [[DollarPlus|$+]] . , %val = [[$hget]](%table,%id [[DollarPlus|$+]] [[$1-|$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 [[DollarPlus|$+]] [[$1-|$2]]
 
−
  [[If-Then-Else|if]] (%nick.l == 0) && (%nick.r == 0) { [[hdel]] %table %id [[DollarPlus|$+]] -lastnick | [[hdel]] %table %id [[DollarPlus|$+]] -firstnick | [[return]] }
 
−
  [[If-Then-Else|if]] (%nick.l !== 0) { [[hadd]] %table %id [[DollarPlus|$+]] %nick.l [[$gettok]]([[$hget]](%table,%id [[DollarPlus|$+]] %nick.l),1,32) %nick.r }
 
−
  [[If-Then-Else|else]] { [[hadd]] %table %id [[DollarPlus|$+]] -firstnick %nick.r }
 
−
  [[If-Then-Else|if]] (%nick.r !== 0) { [[hadd]] %table %id [[DollarPlus|$+]] %nick.r %nick.l [[$gettok]]([[$hget]](%table,%id [[DollarPlus|$+]] %nick.r),2,32) }
 
−
  [[If-Then-Else|else]] { [[hadd]] %table %id [[DollarPlus|$+]] -lastnick %nick.l }
 
−
}
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.N.REM.MAIN ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
; $1 = nick
 
−
[[alias]] -l auth.n.rem.main {
 
−
  [[Local_Variables|var]] %table = auths.n. [[DollarPlus|$+]] [[$cid]]
 
−
  [[If-Then-Else|if]] (![[$hget]](%table)) { [[return]] }
 
−
  [[Local_Variables|var]] %val = [[$hget]](%table,[[$1-|$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-|$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. [[DollarPlus|$+]] [[$cid]]
 
−
  [[If-Then-Else|if]] (![[$hget]](%table)) { [[return]] }
 
−
  [[hdel]] -w %table [[$chan_(window)|$chan(]][[$1-|$1]]).wid [[DollarPlus|$+]] .*
 
−
  [[Local_Variables|var]] %i = [[$nick_(nick)|$nick(]][[$1-|$1]],0)
 
−
  [[while]] (%i) {
 
−
    [[If-Then-Else|if]] (![[$comchan]]([[$nick_(nick)|$nick(]][[$1-|$1]],%i),2)) { auth.n.rem.main [[$nick_(nick)|$nick(]][[$1-|$1]],%i) }
 
−
    [[dec]] %i
 
−
  }
 
−
}
 
−
 
−
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ALIAS AUTH.N.NICK ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 
−
; $1 = nick  $2 = newnick
 
−
[[alias]] -l auth.n.nick {
 
−
  [[If-Then-Else|if]] ([[$1-|$1]] == [[$1-|$2]]) { [[return]] }
 
−
  [[Local_Variables|var]] %table = auths.n. [[DollarPlus|$+]] [[$cid]]
 
−
  [[If-Then-Else|if]] (![[$hget]](%table)) { [[return]] }
 
−
  [[Local_Variables|var]] %i = [[$comchan]]([[$1-|$2]],0)
 
−
  [[while]] (%i) {
 
−
    [[Local_Variables|var]] %id = [[$chan_(window)|$chan(]][[$comchan]]([[$1-|$2]],%i)).wid [[DollarPlus|$+]] . , %val = [[$hget]](%table,%id [[DollarPlus|$+]] [[$1-|$1]])
 
−
    [[If-Then-Else|if]] (%val) {
 
−
      [[hdel]] %table %id [[DollarPlus|$+]] [[$1-|$1]]
 
−
      [[hadd]] %table %id [[DollarPlus|$+]] [[$1-|$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 [[DollarPlus|$+]] %nick.l [[$gettok]]([[$hget]](%table,%id [[DollarPlus|$+]] %nick.l),1,32) [[$1-|$2]] }
 
−
      [[If-Then-Else|else]] { [[hadd]] %table %id [[DollarPlus|$+]] -firstnick [[$1-|$2]] }
 
−
      [[If-Then-Else|if]] (%nick.r !== 0) { [[hadd]] %table %id [[DollarPlus|$+]] %nick.r [[$1-|$2]] [[$gettok]]([[$hget]](%table,%id [[DollarPlus|$+]] %nick.r),2,32) }
 
−
      [[If-Then-Else|else]] { [[hadd]] %table %id [[DollarPlus|$+]] -lastnick [[$1-|$2]] }
 
−
    }
 
−
    [[dec]] %i
 
−
  }
 
−
  [[Local_Variables|var]] %val = [[$hget]](%table,[[$1-|$1]])
 
−
  [[If-Then-Else|if]] (%val) {
 
−
    [[hdel]] %table [[$1-|$1]]
 
−
    [[hadd]] %table [[$1-|$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) [[$1-|$2]] }
 
−
    [[If-Then-Else|else]] { [[hadd]] %table -firstnick [[$1-|$2]] }
 
−
    [[If-Then-Else|if]] (%nick.r !== 0) { [[hadd]] %table %nick.r [[$1-|$2]] [[$gettok]]([[$hget]](%table,%nick.r),2,32) }
 
−
    [[If-Then-Else|else]] { [[hadd]] %table -lastnick [[$1-|$2]] }
 
−
  }
 
−
}
 

Revision as of 01:08, 3 March 2011

Test....

Retrieved from "https://script.quakenet.org/wiki/index.php?title=Test2&oldid=5616"