Scriptwiki - User contributions [en]

Set

2013-10-25T19:10:50Z

Vliedel: better explanation of -z

Sets the value of %variable to the specified value.
/set [-lsnzuN] <%variable> [value]
{| style="width:100%"
|-
| style="width:10%" | '''''Switch''''' || Style="width:90%" | '''''Meaning'''''
|-
| uN || Unsets %var after N seconds, as long as %var isn't set again. If N is 0, it is unset when script finishes.
|-
| k || Keeps the current -uN setting for a variable.
|-
| n || Treats value as plain text.
|-
| z || Decreases %var by 1 per second until it reaches zero, and then unsets it.
|-
| e || Unsets the variable when mIRC exits.
|-
| l || Sets %var as a local variable, same as using /[[var]] (Deprecated, use /var)
|-
| s || Gives an output: * Set %var to value.
|}

== Example ==
set %fuu bar
set %moo $+ %fuu 42
This will set ''%fuu'' to ''bar'' and then set ''%moobar'' to ''42'', as the variable ''%fuu'' will first be evaluated to ''bar''.

echo -a This is fuu: %fuu

Will echo ''This is fuu: bar''

'''Note:''' The variable %fuu is automatically evaluated in a /set or /var command when it is part of the variable name, however elsewhere the variable must be evaluated using either $eval or evaluation brackets, e.g.
if (%moo [ $+ [ %fuu ] ] == 42)
if ($($+(%,moo,%fuu),2) == 42)

set -u3 %fuu bar
This will set ''%fuu'' to ''bar'' and unset it after ''3'' seconds.

set -s %fuu 3
This will set ''%fuu'' to ''3'' and give an output to the active window: ''* Set %fuu to 3''

== See Also ==
* [[Var|/var]] sets a local variable. 
* [[Unset|/unset]] unsets a variable. 
* [[Unsetall|/unsetall]] unsets all variable from the variable list.

[[Category:Commands]][[Category:Variables]]

Timer

2013-10-15T08:47:07Z

Vliedel: no numbers as timername!

Activates the specified timer to perform the specified command at a specified interval, and optionally at a specified time.
/timer[N/name] [-ceomhipr] [time] <repetitions> <interval> <command>

If you are not connected to a server and a timer is started, it will be an offline timer by default, meaning that it will continue to run whether you are connected to a server on not. If you are connected to a server while starting a timer, it will be an online timer, that will stop if you disconnect. You can make a timer being an offline timer by using the -o switch.

To make a new timer, you can either use /timer without name/number or you can specify a name, without space between the command and the name (/timerfoo ...). If you do not specify a name/number, mIRC will get the first free timernumber it finds and use this.

If you specify a delay of 0 seconds, the timer will trigger immediately after the calling script ends.

You can also specify a time when the timer is supposed to trigger (see example below).

'''Note''' that if you specify 0 repetitions it will continue until you either stop it yourself or you disconnect, in case it is an online timer.

'''Note''' that identifiers usually '''do not''' get re-evaluated during a timer (see example below). To force this, you have to use an exclamation mark after the ''$'' of an identifier (e.g. [[$time|$!time]] or [[$me|$!me]])

You can '''stop''' a timer by using ''/timer<name|N> off'', which will also be able to handle wildcards in the name (see example below).

You can use the following switches:

{|
| width="10%" | '''''Switch''''' || width="90%" | '''''Explanation'''''
|-
| valign="top" | c || will make mIRC "catch up" a timer by executing it more than once during one interval if the real-time interval isn't matching your requested interval.
|-
| m / h || indicates that the interval delay is in milliseconds.
|-
| h || make a high-resolution multimedia timer (uses system resources heavily)
|-
| e || will executes the command associated with the specified timer name (works with wildcard names too).
|-
| p || will pause a timer
|-
| r || will resume a timer
|-
| valign="top" | i || will make a timer dynamically associate with whatever happens to be the active connection. If a server window is closed, the timer is associated with the next available server window.
|}

== Example ==
In the following, we'll always create an [[alias]] to be able to execute commands directly after creating the timer.

alias timertest {
timer 2 2 [[echo]] -a moo!
}
This alias just creates an timer that will echo ''moo!'' to your active window two times with a delay of 2 seconds.

alias timertest {
timercorrect 2 10 echo -a [[$asctime|$!asctime]]
timerwrong 2 10 echo -a $asctime
}
Here we create two timers, one with forcing it to re-evaluate the identifier (the one on top), the other not. You will see the first always echoing the current time, the other always echoing the time when it was started.

alias timertest {
timermilli -m 10 50 echo -a The difference is 50 milliseconds.
}
This timer called milli will echo ''The difference is 50 milliseconds.'' every 0,05 seconds to your active window, all in all 10 times.

alias timertest {
timertime 14:00 1 1 echo -a It is 14:00 o'clock.
}
This one will echo ''It is 14:00 o'clock.'' to the active window when it is 14oclock, as we made the timer trigger then.

timer1* off
We just stop all timers beginning with a 1.

== Notes ==
When using {, } and | in timers they will get evaluated before setting the timer so it is always advisable to avoid stacking commands inside of a timer.

Best practise would be to never try and stack commands inside a timer, instead create an alias with the commands you wish to run and start a timer to execute the alias.
timer 1 5 showme
alias showme {
if ($true) {
echo -ag My name is $mnick
echo -ag And I eat fish.
}
echo -ag That go moo!
}

Although it should be avoided where ever possible it is possible to stack commands using [[$chr]](124) as the command delimiter.
timer 1 5 echo -ag My name is $mnick $chr(124) echo -ag And I eat fish.
;;This will start a timer like this:
* Timer 1 1 time(s) 5s delay echo -ag My name is Dana | echo -ag And I eat fish. (QuakeNet)
It is also possible to use $chr(123) and $chr(125) instead of { and } for stacking commands in an if-then-else.
timer 1 5 if ([[$true]]) $chr(123) echo -ag My name is $mnick $chr(124) echo -ag And I eat fish. $chr(125) $chr(124) echo -ag That go moo!
;;This will start a timer like this:
* Timer 1 1 time(s) 5s delay if ([[$true]]) { echo -ag My name is Dana | echo -ag And I eat fish. } | echo -ag That go moo! (QuakeNet)

Take extra care when using the TIME switch with repeats. The time option is only used for setting the timer. Here is details of how the previously mentioned timed timer initiates.
timer 14:00 1 1 echo -a It is 14:00 o'clock.
;When when the time is 14:00, start a timer which runs once with a delay at 1 second.
;The result would be at 14:00:01 the echo would be displayed.

timer 14:00 0 1 echo -a It is 14:00 o'clock.
;When when the time is 14:00, start a timer which runs continually every second.
;The result would be at 14:00:01,14:00:02,14:00:03,14:00:04,14:00:05,... the echo would be displayed.

;If you wish to run a timer every day there is two options, either set the with a delay of one day or restart the timer.
timer 14:00 0 [[$duration]](1day) echo -a It's 14:00!
;Using the above timer the echo would ''not'' run today but the duration amount 1day/86400 seconds after.
;To overcome that you can either set two timers like this:
timer 14:00 0 $duration(1day) echo -a It's 14:00!
timer 14:00 1 0 echo -a It's 14:00!
;Or if you're using an alias reinitialise the timer.
timer 14:00 1 0 showTime
alias showTime {
.timer 14:00 1 1 showTime
echo -a It's 14:00!
}

'''''Avoid''''' using timer [time] 0 0 as this is almost certainly going to be a mistake.

== See Also ==
* [[timers|/timers]] to stop all timers, take a look at.
* [[$timer]] to get information about a timer.

[[Category:Commands]]
[[Category:Timer Commands and Identifiers]]

QuakeNet

2011-07-19T09:11:22Z

Vliedel:

#Redirect [[:Category:Quakenet]]

Quakenet

2011-07-19T09:11:00Z

Vliedel:

#REDIRECT [[:Category:Quakenet]]

Quakenet

2011-07-19T09:09:45Z

Vliedel:

#REDIRECT [[Category:Quakenet]]

User:Vliedel

2011-04-24T11:58:03Z

Vliedel: that was pretty much incorrect

{{Babel-2|nl|en-3}}

<table border="0">
<tr>
<td>[[Image:Boskabouter.jpg]]</td>
<td>
<table border="0">
<tr><td>Age</td><td>26</td></tr>
<tr valign="top" height="40"><td>Country</td><td>The Netherlands</td></tr>

<tr><td>Words of wisdom</td><td>with wisdom only you can't survive</td></tr>
</table>
</td>
</tr>
</table>
[[Category:Members]]

If-Then-Else

2011-04-07T13:21:09Z

Vliedel: execute F, not return F

__NOTOC__
* Note: This is a reference. For a tutorial please see the [[basic control tutorial]].
The If-then-else statement allows you to compare values and execute different parts of a script based on that comparison. This is a basic structure for any script that includes anything more than one-liners!

if (v1 operator v2) { commands1 }
elseif (v1 operator v2) { commands2 }
else { commands3 }

If the first statement (line) is [[$true]], commands inside the first brackets are executed. If the first if-statement returns [[$false]], script starts looking for an elseif-statement. An elseif-statement is only triggered if the group's if-statement returned $false before. And at last, if none of the if or elseif statements were triggered, commands in else-statement are executed.

One if structure/group can consist of one main if-statement, after it there can be 0 .. N elseif-statements. There can be only one else, which can be understood as the default statement, if none one before were triggered. There doesn't need to be else-statement though.

Every if statement is handled separatly and none of others affect in another.

if (A) { ... }
elseif (B) {
if (C) { ... }
elseif (D) { ... }
elseif (E) { ... }
else { F }
}
elseif (G) { ... }
else { H }

If structure would be hierarchical represented it would look something like this

A If A is true, execute its commands and skip the rest
B If B is true,
\
C check if C, D or E returns true
D
E
F If C, D and E were false, execute F
G If A and B were false and G is true, execute this
H If A, B and G were all false, execute H

== The Operators ==

[[#==|==]] equal to
[[#==|===]] equal to (case-sensitive)
[[#<|<]] less than
[[#>|>]] larger than
[[#<=|<=]] less than or equal to
[[#>=|>=]] larger than or equal to
[[#//|//]] v2 is a multiple of v1
[[#\\|\\]] v2 is not a multiple of v1
[[#&|&]] bitwise comparison
[[#!=|!]] negation operator (!= is opposite of == and !isin is "is not in")

[[#isin|isin]] string v1 is in string v2
[[#isin|isincs]] string v1 is in string v2 (case sensitive)
[[#iswm|iswm]] wildcard string v1 matches string v2
[[#iswm|iswmcs]] wildcard string v1 matches string v2 (case sensitive)
[[#isnum|isnum]] number v1 is a number in the range v2 which is in the form n1-n2 (v2 optional)
[[#isletter|isletter]] letter v1 is a letter in the list of letters in v2 (v2 optional)

[[#isalnum|isalnum]] text contains only letters and numbers
[[#isalpha|isalpha]] text contains only letters
[[#islower|islower]] text contains only lower case letters
[[#isupper|isupper]] text contains only upper case letters

[[#ison|ison]] if v1 is on channel v2
[[#isop|isop]] if v1 is an op on channel v2
[[#ishop|ishop]] if v1 is a halfop on channel v2
[[#isvoice|isvoice]] if v1 has a voice on channel v2
[[#isreg|isreg]] if v1 is a normal nick on channel v2
[[#ischan|ischan]] if v1 is a channel which you are on.
[[#isban|isban]] if v1 is a banned address in the internal ban list for channel v2

[[#isaop|isaop]] if v1 is a user in your auto-op list for channel v2 (v2 optional)
[[#isavoice|isavoice]] if v1 is a user in your auto-voice list for channel v2 (v2 optional)
[[#isignore|isignore]] if v1 is a user in your ignore list with the ignore switch v2 (v2 optional)
[[#isprotect|isprotect]] if v1 is a user in your protect list for channel v2 (v2 optional)
[[#isnotify|isnotify]] if v1 is a user in your notify list.

''Note:'' To negate an operator you can prefix it with an exclamation mark (!).

=== == ===
if (cat == cAt) ;Returns true since == is case-insensitive.
if (cat === cAt) ;Returns false since === is case-sensitive.
The above checks that v1 (cat) matches v2 (cAt).

=== != ===
This isn't actually an operator, but a combination of two operators ! and =. And actually, = isn't an operator either, but in mIRC scripting it can be used instead of == and it works just the way == works. In most mIRC scripts you only see !=, which actually shouldn't be used. Instead, !== should be used to negate ==.

if (cat != cAt) ;Returns false since != is case-insensitive and both values v1 and v2 are equal.
if (cat !== caT) ;Returns false since !== is the same as !=
if (cat !=== cAt) ;Returns true since !=== is case-sensitive and both values v1 and v2 are not equal when case is taken in to consideration.
if (!$away) ;Returns $true if you are NOT away ($away returns $false and ! negates it to $true).

=== < ===
if (6 < 9) ;Returns true because the numerical value 6 is less than 9.
Checks that v1 (6) has a lower numerical value than v2 (9)

=== > ===
if (6 > 9) ;Returns false because the numerical value 6 is not greater than 9.
Checks that v1 (6) has a higher numerical value than v2 (9)

=== <= ===
if (6 <= 9) ;Returns true because the numerical value 6 is less than or equal to 9.
Checks that v1 (6) has a lower or equal numerical value than v2 (9).

=== >= ===
if (6 >= 9) ;Returns false because the numerical value 6 is not greater than or equal to 9.
Checks that v1 (6) has a greater or equal numerical value than v2 (9).

=== // ===
if (3 // 9) ;Returns true because 3 is a multiple of 9.
Multiples of 9 are numbers that when devided in to 9 result in an integer.
You are not limited to positive numbers.

=== \\ ===
if (3 \\ 9) ;Returns false because 3 is a multiple of 9.
\\ is the negate of //

=== & ===
if (N1 & N2) ; This will compare the bits that are [[$biton|turned on]] in the decimal N1 AND N2 in the same way [[$and]]() would.
As long as N1 and N2 share atleast 1 bit the condition is returned as true.

if (13 & 11) ;Is true, see the table below for explanation.
echo -ag $and(13,11) ;returns 9.

If you break down 13 and 11 into their bits as below:
{|class="gallery"
|-
| style="width:100px" | '''''Binary''''' || '''''Value'''''
|-
| 1101 || 13
|-
| 1011 || 11
|-
| style="border:1px dotted #2f6fab; color: Black;" | 1001 || style="border:1px dotted #2f6fab; color: Black;" | 9
|}
if (11 & 4) ;Is false.
echo -ag $and(11,4) ;returns 0.
{|class="gallery"
|-
| style="width:100px" | '''''Binary''''' || '''''Value'''''
|-
| 1011 || 11
|-
| 0100 || 4
|-
| style="border:1px dotted #2f6fab; color: Black;" | 0000 || style="border:1px dotted #2f6fab; color: Black;" | 0
|}
Above you can see, 13 and 11 both have the first bit AND fourth bit on, so the statement is true. The binary 1001 value has a decimal value of 9.
Also you can see, 11 and 4 do not share any common bits, so the statement is false.

=== isin ===
if (cat isin [[$1-]])
Matches for "a ''cat''", "''cat''alog", "impli''cat''e " and any string where "cat" '''is in'''.

=== iswm ===
iswm stands for ''is wildcard match''.

Operators:
* 0 or more characters
? 1 character
& 1 word (atleast 1 or more non-space characters)

if (home*away*lost iswm $1-)
This would match anything starting with home and ending in lost, with away being between home and lost.
It would match, "homeawaylost", "home away lost", "home is missed when you are away or lost", etc.

if (ca?* iswm $1-)
Requires one character after "ca" and allows 0 or more character after it. So it would match for cat, cab, cabin etc.

if ([[$(...)|$(]]I & you) iswm $1-)
Matches any string that consists of "I + one word + you".
Examples would be, "I love you", "I hate you", "I moo you", it would not however match, "I don't love you" since "don't love" contains a space. Note the $( ), it is needed to prevent mirc treat this statement as bitwise comparison.

=== isnum ===

if ($1 isnum) ;Returns true if $1 is of numeric value
if ($1 isnum 10-) ;Returns true if $1 is number higher than or equal to 10
if ($1 isnum 20-30) ;Returns true if $1 is a number between 20 and 30 inclusive

The examples above checks $1, to see;

Is it a number? 
Is it a number above 10? 
Is it a number between 20 and 30?

=== isletter ===

if ($1 isletter) ;Returns true if ''$1'' is a letter, any letter
if ($1 isletter abcdefg) ;Returns true if ''$1'' is in the string of letters ''abcdefg''
if ($1 isletter HelloWorld) ;Returns true if ''$1'' is in the string of letters ''HeloWrd''

* Note that the checking is case-sensitive, the letter ''h'' will not return true if checked against the string ''HelloWorld''.

=== isalnum ===
if (Dana34 isalnum) ;returns true as ''Dana34'' contains letters and numbers only
if (Dana_ isalnum) ;returns false as ''_'' is neither letter nor number

Matches whether the string consists of letters and numbers only.

=== isalpha ===
if (Dana isalpha) ; returns true as ''Dana'' consists of letters only
if (foo42 isalpha) ; returns false as ''42'' is no letter

Isalpha checks whether the word consists of letters only. It doesn't matter whether there are upper or lower case.

=== islower ===
if (moo islower) ; returns true as all letters in ''moo'' are lower case.
if (m0o islower) ; returns true as well as all letters in ''m0o'' are lower case.
if (mooO islower) ; retursn false as there is an upper ''O'' in ''mooO''.
'''Note''' that islower checks whether all letters in the string are lower case. There can still be numbers or other characters in the string $1.

=== isupper ===
if (MOO isupper) ; returns true as ''MOO'' consists of upper case letters only
if (1234 isupper) ; returns true as all letters in ''1234'' are upper case, as there are none.
'''Note''' that it checks whether all letters in $1 are upper case. There can still be numbers or other characters in $1.

=== ison ===
if (Dana ison #help.script) ; returns true as ''Dana'' is in the channel #help.script
if (foo !ison #help.script) ; returns true as ''foo'' is not in #help.script

This checks whether $1 is in the channel $2. Note that you need to be in the same channel to use this.

=== isop ===
if (Dana isop #help.script) ; returns true as ''Dana'' is an operator in #help.script
if (foo isop #help.script) ; returns false as ''foo'' is no operator in #help.script

Checks whether $1 is an operator in $2. Note that you need to be in the same channel to use this.

=== ishop ===
if (moo ishop #mIRC) ; returns true if ''moo'' is an half operator in #mIRC
'''Note''' that QuakeNet does not support halfops. Note also that you need to be in the same channel to use this.

=== isvoice ===
if (Dana isvoice #help.script) ; returns true as ''Dana'' has voice in #help.script.
if (foobar isvoice #help.script) ; returns false as ''foobar'' has no voice in #help.script.
This checks if $1 has voice in $2 or not. Note that you need to be in the same channel to use this.

=== isreg ===
if (Dana isreg #help.script) ; returns false as Dana is no regular user in #help.script.
if (foobar isreg #help.script) ; returns true as foobar is a regular user in #help.script.
This checks whether $1 is a regular user (no voice, no half operator, no operator) in $2. Note that you need to be in the same channel to use this.

=== ischan ===
if (#help.script ischan) ; returns true as you are in #help.script.
if (#foobar ischan) ; returns false as you are no in #foobar.
'''Note''' that it returns true only if you are in this channel.

=== isban ===
if (idiot!*@* isban #mychan) ; returns $true if ''idiot!*@*'' is in your [[:Category:IBL|Internal Ban List]] for the channel #mychan.
if ($ial($me) isban $chan) ; returns $true if you are banned on the current channel.
'''Note''' that isban performs two different checks, depending on whether v1 contains wildcards or not:
* if v1 contains wildcards, isban will return $true if v1 is an exact ban in the IBL;
* if v1 does not contain wildcards, isban will return $true if one or more bans match that address.

=== isaop ===
if (foobar isaop) ; returns true if ''foobar'' is in your autoop list for any channel.
if (foobar isaop #help.script) ; returns true if ''foobar'' is in your autoop list for #help.script.
To put someone in your autoop-list, take a look at [[Aop|/aop]].

=== isavoice ===
if (foobar isavoice) ; returns true if ''foobar'' is in your autovoicelist for any channel.
if (foobar isavoice #help.script) ; returns true if ''foobar'' is your autovoicelist for #help.script.
To put someone in your autovoicelist, take a look at [[Avoice|/avoice]].

=== isignore ===
if (foobar isignore) ; returns true if ''foobar'' is in your ignore list.
if (foobar isignore c) ; returns true if ''foobar'' is in your ignore list with switch -c.
To get a more in detail explanation of these switches, take a look at [[Ignore|/ignore]].

=== isprotect ===
if (foobar isprotect) ; returns true if ''foobar'' is in your protect list.
if (foobar isprotect #help.script) ; returns true if ''foobar'' is in your protect list for #help.script.
To get more information about protection, see [[Protect|/protect]].

=== isnotify ===
if (Dana isnotify) ; returns true if Dana is in your notify list.
Take a look at [[Notify|/notify]] to add someone to your notifylist. If someone in your notifylist connects (disconnects), the [[On_notify|On notify event]] ([[On_unotify|On Unotify event]]) is triggered.

== Combining comparisons ==

You can combine comparisons by using the && for AND and || for OR characters.

[[var]] %c = 5
if (%c < 6) && (%c > 0) ; returns true because %c is both, smaller than 6 and greater than 0
if (%c < 6) || (%c isalpha) ; returns true because %c is lower than 6.
; note that %c is not alphapetical and returns false, but || matches for 1 .. N true values.
if (%c < 6) && (%c isalpha) ; returns false
if (%c < 6) && (%c !isalpha) ; ! negates the operator, this this returns true

== Notes ==
====''Not all comparations need two parameters''====
if ($1- isupper)
Returns true if $1- contains only uppercase letters. So ABCD returns true, but even one lowercase letter makes it return false.

====''Use parenthesis correctly''====
(A) || (B) && (C) <- logical order for this is to check if either one of A or B is true, and C is true, but if you wish to check that B and C must be true, or A is true, you'll need to do (A) || ((B) && (C))

====''This article covers only if-then-else '''string''' operators''====
You '''can't''' use
if (foo isin test.txt)
To check the content of a text file, use [[$read]] to search through a file via its search switches.

== See Also ==
* [[$v1]] & [[$v1|$v2]] - These identifiers allow you to retrieve the values of the last if condition.
* [[Basic control tutorial]] - An in depth tutorial on how to use these statements

[[Category:Commands]]

Auth-Update2

2011-03-30T12:31:49Z

Vliedel: new version: fixed delay timing, wait for server reply, copy known auths when joining a chan

This snippet is a new version of [[Auth-Update|Auth_update]]
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; AUTH_UPDATE2 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;
; by Vliedel -- #vliedel @ QuakeNet
; version 2.3 (written and tested on mIRC 6.35)
; 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 -rs1 auth_update2.mrc to load the script (make sure the script it loaded on top)
; - script starts on load or on join
; - to get the auth of a nick use: $auth(nick) or $auth(nick,cid)
; - to get a nick from an auth use: $auth-nick(auth) or $auth-nick(auth,cid)
; - to recheck a nick that was not authed by command use: /auth.update <nick>
; note that rechecking is done automatically, only use this command if you really want to recheck quickly
; - this script should be loaded as last script in your list for optimal usage
;
; - You can use the following example script to see when a nicks auth is updated
; on *:SIGNAL:authupdate.new:{
; if (!$2) { echo -ag $1 is not authed }
; else { echo -ag $1 is authed as $2 }
; }
;
; - The following signal is send when a requested auth is updated (with /auth.update <nick>)
; on *:SIGNAL:authupdate.req:{
; if ($2 == $null) { echo -ag requested: $1 is not on a common chan }
; elseif ($2 == 0) { echo -ag requested: $1 is not authed }
; else { echo -ag requested: $1 is authed as $2 }
; }
;
; Note that these signals return $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.
;
;
;Why is this script good?
;
; - compared with my first auth_update, this script uses less resources, at the cost of a little bit more traffic
; - 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.
;
;
;Since some people do not understand how to use this script on join, here is an example:
;
; on *:JOIN:#:{
; newuser $chan $nick
; }
;
; ; $1 = nick $2 = auth
; on *:SIGNAL:authupdate.new:{
; if (*.users.quakenet.org iswm $ial($1)) { return }
; var %i = 1
; while ($comchan($1,%i)) {
; newuser $v1 $1
; inc %i
; }
; }
;
; ; $1 = chan $2 = nick
; alias -l newuser {
; var %auth = $auth($2)
; if (%auth) { echo 4 -tg $1 $2 is authed as %auth }
; elseif (%auth == 0) { echo 4 -tg $1 $2 is not authed }
; }
;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; SETTINGS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; 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
[[alias]] -l max.replies { [[return]] 1000 }

; 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
[[alias]] -l max.len { [[return]] 400 }

; minimum time (seconds) between two /who commands (default 10)
[[alias]] -l delay { [[return]] 10 }

; time (seconds) between the checking if any unauthed users should be rechecked (default 120)
[[alias]] -l queue.delay { [[return]] 120 }

; time (seconds) to recheck if an unauthed user is now authed (default 600)
[[alias]] -l queue.check { [[return]] 600 }

; minimum ratio of (nicks with unknown auth) / (total nicks) in a channel to do /who #channel rather then /who nick,nick, (default 0.09)
[[alias]] -l min.ratio { [[return]] 0.09 }

; minimum nr of nicks with unknown auth in a channel to do /who #channel rather then /who nick,nick, (default 10)
[[alias]] -l min.nicks { [[return]] 10 }

; 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)
[[alias]] -l used.network {
[[return]] [[$istokcs]](QuakeNet UnderNet GameSurge HanIRC NetGamers OGameNet,[[$network]],32)
}

; For every network a check to see if a user has a site where his authname is in
; $1 is the site
[[alias]] -l auth.in.site {
[[Local_Variables|var]] %n = [[$network]]
[[If-Then-Else|if]] (%n === QuakeNet) { [[return]] [[$iif]](*.users.quakenet.org iswm [[$1-|$1]],[[$true]]) }
[[If-Then-Else|elseif]] (%n === UnderNet) { [[return]] [[$iif]](*.users.undernet.org iswm [[$1-|$1]],[[$true]]) }
[[If-Then-Else|elseif]] (%n === GameSurge) { [[return]] [[$iif]](*.*.GameSurge iswm [[$1-|$1]],[[$true]]) }
[[If-Then-Else|elseif]] (%n === HanIRC) { [[return]] [[$iif]](*.users.HanIRC.org iswm [[$1-|$1]],[[$true]]) }
[[If-Then-Else|elseif]] (%n === NetGamers) { [[return]] [[$iif]](*.users.netgamers.org iswm [[$1-|$1]],[[$true]]) }
[[If-Then-Else|elseif]] (%n === OGameNet) { [[return]] [[$iif]](*.user.OGameNet iswm [[$1-|$1]],[[$true]]) }
}

; For every network the method to return the auth from the site
; $1 is the site
[[alias]] -l auth.from.site {
[[Local_Variables|var]] %n = [[$network]]
[[If-Then-Else|if]] (%n === QuakeNet) { [[return]] [[$gettok]]([[$1-|$1]],1,46) }
[[If-Then-Else|elseif]] (%n === UnderNet) { [[return]] [[$gettok]]([[$1-|$1]],1,46) }
[[If-Then-Else|elseif]] (%n === GameSurge) { [[return]] [[$gettok]]([[$1-|$1]],1,46) }
[[If-Then-Else|elseif]] (%n === HanIRC) { [[return]] [[$gettok]]([[$1-|$1]],1,46) }
[[If-Then-Else|elseif]] (%n === NetGamers) { [[return]] [[$gettok]]([[$1-|$1]],1,46) }
[[If-Then-Else|elseif]] (%n === OGameNet) { [[return]] [[$gettok]]([[$1-|$1]],1,46) }
}

; $auth(nick [,cid]) returns the auth of the nick
[[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]] [[$gettok]]([[$hget]]([[$iif]]([[$1-|$2]],[[$1-|$2]],[[$cid]]) [[DollarPlus|$+]] .auths,[[DollarPlus|$+]](auth.,[[$comchan]]([[$1-|$1]],1),[[$chr]](44),[[$1-|$1]])),1,32)
}

; $auth-nick(auth [,cid]) returns the first nick with that auth
[[alias]] auth-nick {
[[If-Then-Else|if]] ([[$1-|$1]] == [[$null]]) || ([[$1-|$2]] !== [[$null]] && (![[$scid]]([[$1-|$2]]) || ![[$1-|$2]])) { [[return]] }
[[return]] [[$gettok]]([[$hfind]]([[$iif]]([[$1-|$2]],[[$1-|$2]],[[$cid]]) [[DollarPlus|$+]] .auths,[[$1-|$1]],1,n).data,-1,44)
}

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; AUTH.UPDATE ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; /auth.update nick
[[alias]] auth.update {
[[If-Then-Else|if]] (!$used.network) || (![[$comchan]]([[$1-|$1]],1)) { [[return]] }
[[Local_Variables|var]] %t = [[$cid]] [[DollarPlus|$+]] .auths , %a = [[$hget]](%t,[[DollarPlus|$+]](auth.,[[$comchan]]([[$1-|$1]],1),[[$chr]](44),[[$1-|$1]]))
[[If-Then-Else|if]] (0 * iswm %a) { [[hdel]] -w %t [[DollarPlus|$+]](auth.,*,[[$chr]](44),[[$1-|$1]]) }
[[If-Then-Else|if]] (!%a) || (0 * iswm %a) { au.update n [[$1-|$1]] | [[hadd]] %t req. [[DollarPlus|$+]] [[$1-|$1]] 1 }
[[If-Then-Else|else]] { .[[signal]] authupdate.req [[$1-|$1]] %a }
}

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; AU.UPDATE ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; $1 = t/n/c/r/d (timer nick chan repeat delay)
; [$1- = n nick]
[[alias]] -l au.update {
[[Local_Variables|var]] %t = [[$cid]] [[DollarPlus|$+]] .auths
[[If-Then-Else|if]] (![[$hget]](%t)) { [[hmake]] %t }
[[Local_Variables|var]] %tim = au.update.delay. [[DollarPlus|$+]] [[$cid]] , %w = [[$hget]](%t,who) , %l = [[$hget]](%t,wholock)
; when not called by repeat or delay, we probably have something to /who
[[If-Then-Else|if]] (([[$1-|$1]] != r) && ([[$1-|$1]] != d)) { [[hadd]] %t who 1 }
; if we're waiting for reply, don't set timer or /who
[[If-Then-Else|if]] (%l) { [[return]] }
; if called by delay timer and we probably have something to /who, then /who
[[If-Then-Else|if]] (([[$1-|$1]] == d) && (%w)) { au.who | [[return]] }
; if delay timer hasn't been set already, we want to /who or set the timer
[[If-Then-Else|if]] (!$timer(%tim)) {
; if we just joined a chan or just finished a /who, then set delay timer
[[If-Then-Else|if]] (([[$1-|$1]] == c) || ([[$1-|$1]] == r)) { .[[timer]] [[DollarPlus|$+]] %tim 1 $delay au.update d }
[[If-Then-Else|else]] { au.who [[$iif]]([[$1-|$1]] == n,[[$1-|$2]]) }
}
}

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; NICKLIST CHANGING EVENTS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
on ^*:JOIN:#:{
[[Local_Variables|var]] %t = [[$cid]] [[DollarPlus|$+]] .auths
[[If-Then-Else|if]] (!$used.network) { [[return]] }
[[If-Then-Else|if]] ([[$nick_(remote)|$nick]] == [[$me]]) {
au.start
[[return]]
}
[[If-Then-Else|if]] (![[$hget]](%t)) { [[return]] }
[[If-Then-Else|if]] ([[$hfind]](%t,[[DollarPlus|$+]](auth.*,[[$chr]](44),[[$nick_(remote)|$nick]]),1,w)) { [[hadd]] %t [[DollarPlus|$+]](auth.,[[$chan_(remote)|$chan]],[[$chr]](44),[[$nick_(remote)|$nick]]) [[$hget]](%t,[[$v1]]) }
[[If-Then-Else|elseif]] ($auth.in.site($site)) { au.upd.nick [[$nick_(remote)|$nick]] $site }
[[If-Then-Else|else]] { au.update n [[$nick_(remote)|$nick]] }
}

;366 Vliedel #vliedel :End of /NAMES list.
RAW 366:*:{
[[Local_Variables|var]] %c = [[$1-|$2]], %i = [[$nick_(nick)|$nick(]]%c,0), %w = auth.* [[DollarPlus|$+]] [[$chr]](44), %it = [[DollarPlus|$+]](auth.,%c,[[$chr]](44)), %t = [[$cid]] [[DollarPlus|$+]] .auths
[[while]] (%i) {
[[Local_Variables|var]] %n = [[$nick_(nick)|$nick(]]%c,%i)
[[If-Then-Else|if]] ([[$hfind]](%t,%w [[DollarPlus|$+]] %n,1,w)) {
[[tokenize]] 32 [[$hget]](%t,[[$v1]])
[[hadd]] %t %it [[DollarPlus|$+]] %n [[$1-|$1]] [[$iif]]([[$1-|$2]],%c) [[$1-|$3]]
}
[[dec]] %i
}
au.update c
}

on *:PART:#:{ au.part [[$chan_(remote)|$chan]] [[$nick_(remote)|$nick]] | au.upd.nick [[$nick_(remote)|$nick]] $site [[$chan_(remote)|$chan]] }
on *:KICK:#:{ au.part [[$chan_(remote)|$chan]] $knick | au.upd.nick [[$nick_(remote)|$nick]] $site }

; $1 = chan $2 = nick
[[alias]] -l au.part {
[[Local_Variables|var]] %t = [[$cid]] [[DollarPlus|$+]] .auths
[[If-Then-Else|if]] (![[$hget]](%t)) { [[return]] }
[[If-Then-Else|if]] ([[$1-|$2]] == [[$me]]) {
[[hdel]] -w %t auth. [[DollarPlus|$+]] [[$chan_(remote)|$chan]] [[DollarPlus|$+]] ,*
[[hdel]] %t ctime. [[DollarPlus|$+]] [[$chan_(remote)|$chan]]
[[Local_Variables|var]] %i = [[$hfind]](%t,req.*,0,w)
[[while]] (%i) {
[[Local_Variables|var]] %it = [[$hfind]](%t,req.*,%i,w) , %n = [[$gettok]](%it,2,46)
[[If-Then-Else|if]] (%n ison [[$1-|$1]]) && (![[$comchan]](%n,2)) { [[hdel]] %t %it | .[[signal]] authupdate.req %n }
[[dec]] %i
}
}
[[If-Then-Else|else]] {
[[hdel]] %t [[DollarPlus|$+]](auth.,[[$1-|$1]],[[$chr]](44),[[$1-|$2]])
[[If-Then-Else|if]] ([[$hget]](%t,req. [[DollarPlus|$+]] [[$1-|$2]])) && (![[$comchan]]([[$1-|$2]],2)) { [[hdel]] %t req. [[DollarPlus|$+]] [[$1-|$2]] | .[[signal]] authupdate.req [[$1-|$2]] }
}
}

on *:QUIT:{
[[Local_Variables|var]] %t = [[$cid]] [[DollarPlus|$+]] .auths
[[If-Then-Else|if]] (![[$hget]](%t)) { [[return]] }
[[hdel]] -w %t [[DollarPlus|$+]](auth.,*,[[$chr]](44),[[$nick_(remote)|$nick]])
[[If-Then-Else|if]] ([[$hget]](%t,req. [[DollarPlus|$+]] [[$nick_(remote)|$nick]])) { [[hdel]] %t req. [[DollarPlus|$+]] [[$nick_(remote)|$nick]] | .[[signal]] authupdate.req [[$nick_(remote)|$nick]] }
}

on ^*:NICK:{
[[Local_Variables|var]] %i = [[$comchan]]($newnick,0) , %t = [[$cid]] [[DollarPlus|$+]] .auths
[[If-Then-Else|if]] ([[$nick_(remote)|$nick]] == $newnick) || (![[$hget]](%t)) { [[return]] }
[[while]] (%i) {
[[Local_Variables|var]] %it = [[DollarPlus|$+]](auth.,[[$comchan]]($newnick,%i),[[$chr]](44))
[[$iif]]([[$hget]](%t,%it [[DollarPlus|$+]] [[$nick_(remote)|$nick]]),hadd,hdel) %t %it [[DollarPlus|$+]] $newnick [[$v1]]
[[hdel]] %t %it [[DollarPlus|$+]] [[$nick_(remote)|$nick]]
[[dec]] %i
}
[[If-Then-Else|if]] ([[$hget]](%t,req. [[DollarPlus|$+]] [[$nick_(remote)|$nick]])) { [[hadd]] %t req. [[DollarPlus|$+]] $newnick 1 | [[hdel]] %t req. [[DollarPlus|$+]] [[$nick_(remote)|$nick]] }
[[If-Then-Else|if]] ($auth.in.site($site)) { au.upd.nick $newnick $site }
}

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; AU.WHO ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; [$1 = nick]
[[alias]] -l au.who {
[[Local_Variables|var]] %t = [[$cid]] [[DollarPlus|$+]] .auths , %t2 = [[$cid]] [[DollarPlus|$+]] .au.who
[[If-Then-Else|if]] ([[$hget]](%t2)) { [[hfree]] %t2 }
[[hmake]] %t2
[[hdel]] %t who
[[If-Then-Else|if]] ([[$1-|$1]]) {
[[Local_Variables|var]] %who = [[$1-|$1]] [[DollarPlus|$+]] ,,, [[DollarPlus|$+]] 137
[[hadd]] %t2 -mask %who
[[hadd]] %t wholock 1
who %who n%nat,137
[[return]]
}
[[Local_Variables|var]] %i = [[$comchan]]([[$me]],0) , %sort , %ticks = [[$ticks]]
[[while]] (%i) {
[[Local_Variables|var]] %sort = %sort [[$nick_(nick)|$nick(]][[$comchan]]([[$me]],%i),0) [[DollarPlus|$+]] . [[DollarPlus|$+]] %i
[[dec]] %i
}
[[Local_Variables|var]] %sort = [[$sorttok]](%sort,32,n) , %i = [[$numtok]](%sort,32) , %maxlen = $max.len , %n.max = $max.replies , %time = [[$calc]]([[$ctime]] - $queue.check) , %ids , %n.w , %len, %chans
[[while]] (%i) {
[[Local_Variables|var]] %c = [[$comchan]]([[$me]],[[$gettok]]([[$gettok]](%sort,%i,32),2,46)) , %n.0 = [[$hfind]](%t,0 %c &,0,w).data , %n.c = [[$nick_(nick)|$nick(]]%c,0)
[[Local_Variables|var]] %n.l = [[$calc]](%n.c - [[$hfind]](%t,[[DollarPlus|$+]](auth.,%c,[[$chr]](44),*),0,w) + [[$iif]](%time < [[$hget]](%t,ctime. [[DollarPlus|$+]] %c),0,%n.0))
[[If-Then-Else|if]] ([[$calc]](%len + [[$len]](%c) +1) > %maxlen) || ([[$calc]](%n.w + %n.c) > %n.max) { [[dec]] %i | [[continue]] }
[[If-Then-Else|if]] (%n.l > 1) && ((%n.l >= $min.nicks) || ([[$calc]](%n.l / %n.c) >= $min.ratio)) {
[[Local_Variables|var]] %chans = %chans %c
[[hadd]] %t ctime. [[DollarPlus|$+]] %c [[$ctime]]
[[Local_Variables|var]] %j = [[$nick_(nick)|$nick(]]%c,0)
[[while]] (%j) {
[[Local_Variables|var]] %n = [[$nick_(nick)|$nick(]]%c,%j)
[[If-Then-Else|if]] (![[$hget]](%t2,%n)) { [[hadd]] %t2 %n 1 | [[inc]] %n.w }
[[dec]] %j
}
[[inc]] %len [[$calc]]([[$len]](%c) +1)
}
[[dec]] %i
}
[[Local_Variables|var]] %i = [[$comchan]]([[$me]],0) , %nicks
[[while]] (%i) {
[[Local_Variables|var]] %c = [[$comchan]]([[$me]],%i)
[[If-Then-Else|if]] (![[$istok]](%chans,%c,32)) {
[[If-Then-Else|if]] ([[$calc]]([[$nick_(nick)|$nick(]]%c,0) - [[$hfind]](%t,[[DollarPlus|$+]](auth.,%c,[[$chr]](44),*),0,w)) > 0) {
[[Local_Variables|var]] %j = [[$nick_(nick)|$nick(]]%c,0)
[[while]] (%j) {
[[Local_Variables|var]] %n = [[$nick_(nick)|$nick(]]%c,%j)
[[If-Then-Else|if]] ([[$calc]](%len + [[$len]](%n) +1) > %maxlen) { [[goto]] end }
[[Local_Variables|var]] %val = [[$hget]](%t,[[DollarPlus|$+]](auth.,%c,[[$chr]](44),%n))
[[If-Then-Else|if]] (![[$hget]](%t2,%n)) && ((%val == [[$null]]) || ([[$gettok]](%val,3,32) < %time)) { [[Local_Variables|var]] %nicks = %nicks %n | [[hadd]] %t2 %n 1 | [[inc]] %n.w | [[inc]] %len [[$len]](%n) }
[[If-Then-Else|if]] (%n.w >= %n.max) { [[goto]] end }
[[dec]] %j
}
}
[[If-Then-Else|else]] {
[[Local_Variables|var]] %j = [[$hfind]](%t,0 %c &,0,w).data
[[while]] (%j) {
[[Local_Variables|var]] %it = [[$hfind]](%t,0 %c &,%j,w).data , %n = [[$gettok]](%it,2,44)
[[If-Then-Else|if]] ([[$calc]](%len + [[$len]](%n) +1) > %maxlen) { [[goto]] end }
[[If-Then-Else|if]] (![[$hget]](%t2,%n)) && ([[$gettok]]([[$hget]](%t,%it),3,32) < %time) && (auth.* iswm %it) { [[Local_Variables|var]] %nicks = %nicks %n | [[hadd]] %t2 %n 1 | [[inc]] %n.w | [[inc]] %len [[$len]](%n) }
[[If-Then-Else|if]] (%n.w >= %n.max) { [[goto]] end }
[[dec]] %j
}
}
}
[[dec]] %i
}
:end
[[Local_Variables|var]] %who = [[$replace]](%chans %nicks,[[$chr]](32),[[$chr]](44))
[[If-Then-Else|if]] (%who) {
[[Local_Variables|var]] %who = %who [[DollarPlus|$+]] ,,, [[DollarPlus|$+]] 137
[[hadd]] %t2 -mask %who
[[hadd]] %t wholock 1
who %who n%nat,137
[[If-Then-Else|if]] (%len > [[$calc]](%maxlen * 0.7)) || (%n.w > [[$calc]](%n.max * 0.7)) { [[hadd]] %t who 1 }
}
[[If-Then-Else|else]] { au.update r }
}

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; RAW REPLIES ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; RAW 354 SPECIAL WHO REPLY
; 354 <you> <nr> <nick> <auth>
; 354 Vliedel 137 sy rry
RAW 354:& 137 & &:{
[[haltdef]]
[[Local_Variables|var]] %i = [[$comchan]]([[$1-|$3]],0) , %t = [[$cid]] [[DollarPlus|$+]] .auths
[[If-Then-Else|if]] ([[$hget]](%t,req. [[DollarPlus|$+]] [[$1-|$3]])) { [[hdel]] %t req. [[DollarPlus|$+]] [[$1-|$3]] | .[[signal]] authupdate.req [[$1-|$3]] [[$iif]](%i,[[$1-|$4]]) }
[[If-Then-Else|if]] (!%i) || (![[$hget]](%t)) { [[return]] }
[[If-Then-Else|if]] ([[$gettok]]([[$hget]](%t,[[DollarPlus|$+]](auth.,[[$comchan]]([[$1-|$3]],1),[[$chr]](44),[[$1-|$3]])),1,32) !== [[$1-|$4]]) { .[[signal]] authupdate.new [[$1-|$3]] [[$1-|$4]] }
[[while]] (%i) {
[[Local_Variables|var]] %c = [[$comchan]]([[$1-|$3]],%i)
[[hadd]] %t [[DollarPlus|$+]](auth.,%c,[[$chr]](44),[[$1-|$3]]) [[$1-|$4]] [[$iif]](![[$1-|$4]],%c [[$ctime]])
[[dec]] %i
}
}

; RAW 315 WHO END
; 315 <you> <requested> :End of /who list.
; 315 Vliedel #vliedel,,,137 :End of /WHO list.
RAW 315:& *,,,137 end of /WHO list.: {
[[If-Then-Else|if]] ([[$hget]]([[$cid]] [[DollarPlus|$+]] .au.who,-mask) == [[$1-|$2]]) {
[[Local_Variables|var]] %who = [[$left]]([[$1-|$2]],-6) , %i = [[$wildtok]](%who,#*,0,44) , %t = [[$cid]] [[DollarPlus|$+]] .auths
[[while]] (%i) {
[[hadd]] %t ctime. [[DollarPlus|$+]] [[$wildtok]](%who,#*,%i,44) [[$ctime]]
[[dec]] %i
}
[[hfree]] [[$cid]] [[DollarPlus|$+]] .au.who
[[hdel]] %t wholock
au.update r
[[haltdef]]
}
}

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; STARTING AND STOPPING ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
on *:LOAD:{ scon -at1 au.load l }
[[alias]] -l au.load {
au.stop
au.start
au.update t
}

[[alias]] -l au.stop {
.[[timer]] [[DollarPlus|$+]] au.update. [[DollarPlus|$+]] [[$cid]] off
.[[timer]] [[DollarPlus|$+]] au.update.delay. [[DollarPlus|$+]] [[$cid]] off
[[If-Then-Else|if]] ([[$hget]]([[$cid]] [[DollarPlus|$+]] .auths)) { [[hfree]] [[$v1]] }
[[If-Then-Else|if]] ([[$hget]]([[$cid]] [[DollarPlus|$+]] .au.who)) { [[hfree]] [[$v1]] }
}

[[alias]] -l au.start {
[[If-Then-Else|if]] (!$used.network) { [[return]] }
[[If-Then-Else|if]] (![[$hget]]([[$cid]] [[DollarPlus|$+]] .auths)) { [[hmake]] [[$cid]] [[DollarPlus|$+]] .auths }
[[If-Then-Else|if]] (!$timer(au.update. [[DollarPlus|$+]] [[$cid]])) { .[[timer]] [[DollarPlus|$+]] au.update. [[DollarPlus|$+]] [[$cid]] 0 $queue.delay au.update t }
}

on *:DISCONNECT:{ au.stop }
on *:UNLOAD:{ scon -a au.stop }

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; IAL-UPDATING EVENTS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
on ^*:TEXT:*:*:{ au.upd.nick [[$nick_(remote)|$nick]] $site }
on ^*:ACTION:*:*:{ au.upd.nick [[$nick_(remote)|$nick]] $site }
on ^*:NOTICE:*:*:{ au.upd.nick [[$nick_(remote)|$nick]] $site }
on ^*:RAWMODE:#:{ au.upd.nick [[$nick_(remote)|$nick]] $site }
on ^*:TOPIC:#:{ au.upd.nick [[$nick_(remote)|$nick]] $site }
on ^*:INVITE:#:{ au.upd.nick [[$nick_(remote)|$nick]] $site }
[[CTCP]] *:*:*:{ au.upd.nick [[$nick_(remote)|$nick]] $site }
RAW 352:& & & & & & & & *:{ au.upd.nick [[$1-|$6]] [[$1-|$4]] }

; $1 = nick $2 = site [ $3 = chan (exclude it)]
[[alias]] -l au.upd.nick {
[[If-Then-Else|if]] (!$auth.in.site([[$1-|$2]])) || (![[$hget]]([[$cid]] [[DollarPlus|$+]] .auths)) { [[return]] }
[[Local_Variables|var]] %i = [[$comchan]]([[$1-|$1]],0) , %t = [[$cid]] [[DollarPlus|$+]] .auths , %au = $auth.from.site([[$1-|$2]])
[[If-Then-Else|if]] (!%i) || (%i == 1 && [[$1-|$3]]) || ([[$hget]](%t,[[DollarPlus|$+]](auth.,[[$comchan]]([[$1-|$1]],1),[[$chr]](44),[[$1-|$1]])) == %au) { [[return]] }
[[while]] (%i) {
[[If-Then-Else|if]] ([[$comchan]]([[$1-|$1]],%i) !== [[$1-|$3]]) { [[hadd]] %t [[DollarPlus|$+]](auth.,[[$v1]],[[$chr]](44),[[$1-|$1]]) %au }
[[dec]] %i
}
.[[signal]] authupdate.new [[$1-|$1]] %au
}

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; USED DATA/TIMERS ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

; TABLE <cid>.auths
;auth.<chan>,<nick> --> <auth> [chan ctime]
;req.<nick> --> 1
;ctime.<chan> --> <ctime>
;who --> <1/null>
;wholock --> <1/null>

; TABLE <cid>.au.who
; nick --> 1
; -mask --> /who string

; TIMER au.update.delay.<cid>
; TIMER au.update.<cid>

[[Category:Script_Archive]]

Auth-Update2

2011-03-10T15:17:00Z

Vliedel: /load -rs1 to make sure the script is on top

Auth-Update2

2011-03-10T15:16:02Z

Vliedel: added on join example

Why and how to use File Handlers

2011-03-07T23:25:15Z

Vliedel: enhanced example script

File handlers are mIRC's most primitive method of handling file operations. If you are familiar with lower-level programing languages such as the popular C family and its derivatives, you will better recognize their functionality as that of "Streams". In these lower level languages, there are Input streams and Output streams (For reading from and writing to a file respectively), but mIRC uses file handling for both.

So why use file handlers when mIRC is a high level language and provides us with such useful and easy methods as the [[$read]]() identifier and [[write]] command? Consider the following code that reads from every line in the file with $read and a [[While_loops|while loop]].

[[Aliases|alias]] example {
[[var]] %i = 1
while (%i [[If#.3C.3D|<=]] [[$lines]](examplefile.txt)) {
[[noop]] $read(examplefile.txt,n,%i)
[[inc]] %i
}
}

When mIRC uses $read, it internally opens a "stream" with the file and goes through each line until it reaches the line it was told. Since we give it a number, it counts the lines. On the first round, mIRC reads line "1", sees we asked for line "1", and is done. On the second time however, it reads line "1", sees we asked for "2", keeps going, and sees line "2", its done. This will continue for line 3 (1 2 3) and 4 (1 2 3 4) until we are finished. If examplefile.txt were 50 lines big, mIRC would internally read 1275 lines before finishing. The formula for this if you're curious is: (1 + lines)*lines/2

So obviously there are performance issues with $read. If you think you will never have to do this, consider having to perform reverse wild card matches (wild card address in a file vs. full addresses, where you can't wild card search with $read), or parsing a downloaded web page.

==Opening a Stream==

A file handler stream must be opened when you want to begin, and closed when you are done. You will not be able to open two handlers of the same name without closing one first, nor will you be able to perform an operation on a stream you have not yet opened.
/[[fopen]] [-no] <Stream Name> <File Name>
This command opens a stream, assuming it is not opened already.

*The -n switch will make this stream only work if the file doesn't exist, and will create it for you. If it does exist, the command will give an error.
*The -o switch will create the file if it doesn't exist, and overwrite it if it does.
Without either of these switches, the command will give an error if the file does not exist, as it will be unable to create the stream.

Throughout this tutorial I will be using a file called bans.txt to illustrate my point. At the end, we will create an efficient alias ($isbanned(Address)) that will search the file line by line and see if any line wild card matches Address, returning [[$true]] or [[$false]] accordingly. I will build on it as we go, here is the first code to create the stream.

alias isbanned {
if (![[$isfile]](bans.txt)) { [[return]] $false }
.fopen bancheck bans.txt
}

This opens a stream called "bancheck" with the file "bans.txt". The first line stops if "bans.txt" doesn't exist, because obviously the address can't be banned! The . in front of fopen is a "silent" command prefix, which keeps it from telling us about the file handler being opened. Most people don't care :)

==Status of a Stream==

[[$fopen]] has nothing inherent to do with opening the stream, its used to check the status of file handlers. After opening the handler in isbanned, we did not close it. At this point, if we were to [[echo]] $fopen(bancheck) it would return "bancheck", proving that the stream was opened. If it were not opened, it would return "[[$null]]". You can also use $fopen(N) to get file handler number N, 0 of course returning the total number of opened streams. $fopen(1), assuming this was the only file handler opened, would also return "bancheck", $fopen(0) would return 1.

Properties of $fopen:
*''fname'' returns the name of the file the stream is reading from. $fopen(bancheck).fname would return "bans.txt"
*''pos'' returns the current position of the file pointer. Think of the pointer as the blinking | on the screen when you type. As you read, the pointer advances to the next part of the file (after the last character you read). pos returns a number in bytes, basically the number of characters (letters, numbers, spaces) that have already been read. If the first line contained "foo bar" and we have read to "foo", .pos would return "3", as in three characters read. $fopen(bancheck).pos would return 0 as we have not read any bytes from the stream yet.
*''eof'' returns a $true or $false value based on whether or not the pointer has reached the end of the file (EoF is a general programing term for end of stream or, "End Of File"). You should note that if you intend to keep a stream open, .eof will bug as of version 6.21, because it is set to the number of bytes that were in the file when you began your read. If new text is written to the file while your pointer is opened (say from 30 to 50 bytes), once .pos was 30, .eof would be true, even though you were not technically at the end of the file. I recommend comparing .pos to [[$file]](name).size instead of using if with eof. $fopen(bancheck).eof would return $false since we are not yet at the end of the file bans.txt
*''err'' simply returns an error code if there was one. $fopen(bancheck).err would return 0 because we have had no errors (hopefully).

alias isbanned {
if (!$isfile(bans.txt)) { return $false }
if ($fopen(bancheck)) { .[[fclose]] bancheck }
.fopen bancheck bans.txt
}

Here we add a check to make sure bancheck is not already opened for some reason, and close it if it is, avoiding the "name already in use" error.

==Reading from the Stream==

There are two ways to read from a stream. You can use [[$fread]] or [[$fgetc]].

*$fgetc(file handler name | file handler number) will return the next character after the current pointer position, and advanced the pointer past that character: assume the pointer is at the end of the bold characters: Before $fgetc: '''a'''bc, After: '''ab'''c
**Returns: b, the next character in line.
*$fread(name|number) will return the next line after the pointer, and advanced the pointer past that line.
*$fread(name|number,M,&bvar) will read from the current pointer position, the next M bytes into &bvar
**To learn about binary variables, see the [[:Category:Binary_Files|Binary Files]] category.

alias isbanned {
if (!$isfile(bans.txt)) { return $false }
if ($fopen(bancheck)) { .fclose bancheck }
.fopen bancheck bans.txt
while (!$fopen(bancheck).eof) {
var %thisAddress = $fread(bancheck)
}
}

This would read every line in consecutive, non recursive order, setting the line to %thisAddress. Remember, without using $fread or $fgetc this loop would be infinite because the pointer would never advance and never reach the end of file (.eof)

Another way to do this is (more effective yet slower):

alias isbanned {
if (!$isfile(bans.txt)) { return $false }
if ($fopen(bancheck)) { .fclose bancheck }
.fopen bancheck bans.txt
while ($fopen(bancheck).pos < $file(bans.txt).size) {
var %thisAddress = $fread(bancheck)
}
}

This of course would read until the pointer is at the last position in the file (The last byte, its size in bytes).

==Searching for Text in a Stream==

File handlers support a bit of high-level influence, allowing you to search for a location in the stream and set the pointer to it using /[[fseek]]. Each seek is from the current position of the pointer foward.
/fseek [-lnwr] <Stream Name> <Pattern>
* If you do not use a switch, it will look for the next occurance of the words you specify as pattern.
* If you use -l, it will go to the Nth line (ie line 5, 5 as the pattern.)
* If you use -n, it will seek to the next line automatically. This is fairly useless, in all honesty, but use as needed.
* If you use -w, it will look by wild card as the pattern (*foobar*)
* If you use -r, it will use a regular expression as the pattern (see http://www.regular-expressions.info or another tutorial to learn how to use these)

We might, for example, wish to start looking at the line that reads "Start Here", so we would use after opening the file:
.fseek bancheck Start Here
It is important to note that the pointer will be placed at the "S" in start here (The first byte in the found string), so to start reading after it, we should use:
noop $fread(bancheck)
This will read the next line (and do nothing with it), but will advanced the pointer past the line, letting us start after it.

==Final Notes==

* fclose can use wild cards as well, .fclose * closes everything
* If an error occurs, the handlers will not be closed and the reading will stop, do not forget to check to see if it is opened before trying to open it again, or you will have errors in your script.
* $feof and $ferr are the values of .eof and .err for the last file handlers read from.
.[[flist]] [name | wildcard]
* This will list all file handlers matching name or wild card; no parameter will list all file handlers.
.fwrite [-bn] <Stream Name> <Text | &Binvar>
*This will write a binary (provided -b is specified), or text (-n will add an endline character) into the stream at the current position of the pointer.

==Final Product==
I'll leave you to analyze this and use what you have learned to understand it - now go and use $read ineffectively no more!
alias isbanned {
if (!$isfile(bans.txt)) return $false
if ($fopen(bancheck)) .fclose bancheck
.fopen bancheck bans.txt
if ($fopen(bancheck).err) return $false
while ($fopen(bancheck).pos < $file(bans.txt).size) {
var %thisAddress = $fread(bancheck)
if (%thisAddress iswm $1) return $true
}
return $false
}

==Example==
A test alias showing speed differences of /fwrite & /write and $fread & $read

[[alias]] filetest {
[[If-Then-Else|if]] ([[$isfile]](filetest.txt)) { [[echo]] -ag The file filetest.txt already exists! | halt }
[[If-Then-Else|if]] ($fopen(filetest)) { .[[fclose]] filetest }

[[Local_Variables|var]] %max = 1000, %str = [[$str]](x,100)

;; WRITE-part

[[Local_Variables|var]] %x = %max, %t = [[$ticks]]
.[[fopen]] -n filetest filetest.txt
[[while]] (%x) {
.[[fwrite]] -n filetest %str
[[dec]] %x
}
.[[fclose]] filetest
[[echo]] -ag /fwrite with %max lines: [[$calc]]([[$ticks]] - %t) [[DollarPlus|$+]] ms
.[[remove]] filetest.txt

[[Local_Variables|var]] %x = %max, %t = [[$ticks]]
[[while]] (%x) {
[[write]] filetest.txt %str
[[dec]] %x
}
[[echo]] -ag /write with %max lines: [[$calc]]([[$ticks]] - %t) [[DollarPlus|$+]] ms

;; READ-part

[[Local_Variables|var]] %t = [[$ticks]]
.[[fopen]] filetest filetest.txt
[[while]] (!$fopen(filetest).eof) {
[[noop]] -qg $fread(filetest)
}
.[[fclose]] filetest
[[echo]] -ag $ [[DollarPlus|$+]] fread with %max lines: [[$calc]]([[$ticks]] - %t) [[DollarPlus|$+]] ms

[[Local_Variables|var]] %x = %max,%t = [[$ticks]]
[[while]] (%x) {
[[noop]] [[$read]](filetest.txt,%x)
[[dec]] %x
}
[[echo]] -ag $ [[DollarPlus|$+]] read with %max lines: [[$calc]]([[$ticks]] - %t) [[DollarPlus|$+]] ms
.[[remove]] filetest.txt
}

I got these results:
/fwrite with 5000 lines: 171ms
/write with 5000 lines: 1844ms
$fread with 5000 lines: 156ms
$read with 5000 lines: 16969ms

{{Author|aca20031}}
[[Category:Tutorials]]
[[Category:File Handling]]

How to query a CS Server

2011-02-13T20:06:00Z

Vliedel: removed dead links

How to query a CS Server

2011-02-13T19:58:23Z

Vliedel:

How to RCON a source engine based server

2011-02-13T19:58:01Z

Vliedel:

; Source RCON control snippet by NaNg
; Date: 12-02-2011
; Tested on mIRC 7.14
;
; Remote control window for Source engine based games (e.g. HL2, OrangeBox, CS:S, CSP etc.),
; based on the Source RCON Protocol found at http://developer.valvesoftware.com/wiki/Source_RCON_Protocol
;
; Warning! I couldn't find a perfect way to open the socket nicely everytime it closes, so don't rely on it
; to be connected 24/7 (plus, the socket is closed on the server side every changelevel).
;
; Usage:
; * /sourcercon <ip> <port> <pass>

; Define a prefix for sockent names.
[[alias]] -l srcon.prefix { [[return]] SRcon }

; Set the command requests and response types.
[[alias]] -l srcon.req.execcmd { [[return]] 2 }
[[alias]] -l srcon.req.auth { [[return]] 3 }
[[alias]] -l srcon.res.cmd { [[return]] 0 }
[[alias]] -l srcon.res.auth { [[return]] 2 }

; Turn the given number to a 4-byte number.
[[alias]] -l srcon.inttobytes {
[[tokenize]] 46 [[$longip]]([[$1-|$1]])
[[return]] [[$1-|$4]] [[$1-|$3]] [[$1-|$2]] [[$1-|$1]]
}

; Validates arguments and tries to open the socket to the game server for authentication.
[[alias]] sourcercon {
; Validate arguments (simple, no need for full validation).
[[If-Then-Else|if]] ((![[$longip]]([[$1-|$1]])) || ([[$1-|$2]] !isnum 1-65536) || (![[$1-|$3]])) {
[[echo]] -ag Invalid parameters.
[[return]]
}

; Save the server's address.
[[Local_Variables|var]] %server.addr = [[DollarPlus|$+]]([[$1-|$1]],:,[[$1-|$2]])

; Check that the user has not opened a Rcon window for the same server already.
; This makes sure that the user won't have a Rcon step over another Rcon for the same server.
[[If-Then-Else|if]] ([[$window_(remote)|$window(]]%server.addr)) {
[[echo]] -ag Rcon window for [[$1-|$1]] is already open! close it before trying.
[[return]]
}

; Open the Rcon window whilst activating it, with an editbox, hide the @ prefix and maximize it.
window -aek0x @ [[DollarPlus|$+]] %server.addr
[[aline]] 12 @ [[DollarPlus|$+]] %server.addr Source RCON window. Type a command\cvar to send to the server, responses will be displayed here.
[[aline]] 12 @ [[DollarPlus|$+]] %server.addr Warning! commands like exit or quit will close the server! avoid using them!

; Set the socket name we'll use.
[[Local_Variables|var]] %sockname = [[DollarPlus|$+]]($srcon.prefix,%server.addr)

; Open the socket to the server.
[[sockopen]] %sockname [[$1-|$1]] [[$1-|$2]]

; Mark the socket with the Rcon password.
[[sockmark]] %sockname [[$1-|$3]]
}

; Catch all sockopens with the Source Rcon sockets prefix.
; Build the authentication request packet and send it to the server.
on *:SOCKOPEN:$([[DollarPlus|$+]]($srcon.prefix, *)): {
; Initialize the request ID for the connection.
[[set]] %srcon.id. [[DollarPlus|$+]] [[$sockname]] 0

; Constructed auth request to send to the server.
srcon.getrequest &srcon.auth %srcon.id. [ [[DollarPlus|$+]] [ [[$sockname]] ] ] $srcon.req.auth [[$sock]]([[$sockname]]).mark

; Send the authentication packet.
[[sockwrite]] [[$sockname]] &srcon.auth
}

; Read data from the game server.
on *:SOCKREAD:$([[DollarPlus|$+]]($srcon.prefix, *)): {
; Get the window name for the current game server.
[[Local_Variables|var]] %srcon.window = [[DollarPlus|$+]](@, [[$remove]]([[$sockname]], $srcon.prefix))

; If there were errors, $sockerr will tell us so.
; Write the error message to the window and clear the connection.
[[If-Then-Else|if]] ($sockerr) {
[[aline]] 04 %srcon.window * Error: Reading from socket: [[$sock]]([[$sockname]]).wsmsg
srcon.clear [[$sockname]]
[[return]]
}

; If a prior packet didn't finish receiving, continue reading it.
[[If-Then-Else|if]] ([[$hget]]([[$sockname]])) {
; Set the packet size.
[[Local_Variables|var]] %srcon.pckt.size = [[$hget]]([[$sockname]], size)

; Set the number of bytes left to read.
[[Local_Variables|var]] %srcon.pckt.left = [[$hget]]([[$sockname]], left)

; Set the request id.
[[Local_Variables|var]] %srcon.pckt.id = [[$hget]]([[$sockname]], id)

; Set the command response type.
[[Local_Variables|var]] %srcon.pckt.cmd = [[$hget]]([[$sockname]], cmd)

; Set the cut string1.
[[noop]] [[$hget]]([[$sockname]], string1, &srcon.pckt.string1)

; Read the rest of string1.
[[Sockread|sockread]] %srcon.pckt.left &srcon.pckt.rest
[[dec]] %srcon.pckt.left $sockbr

; Append the rest of string1 to the already received string1.
[[bcopy]] &srcon.pckt.string1 [[$calc]]([[$bvar]](&srcon.pckt.string1, 0) + 1) &srcon.pckt.rest 1 -1

; Clear the un-needed variables.
[[hfree]] [[$sockname]]
}
; Else, if the packet wasn't splitted.
[[If-Then-Else|else]] {
; Read the packet size.
[[Sockread|sockread]] 4 &srcon.pckt.size
[[Local_Variables|var]] %srcon.pckt.size = [[$bvar]](&srcon.pckt.size, 1).long

; Initialize the number of bytes left to read.
[[Local_Variables|var]] %srcon.pckt.left = %srcon.pckt.size

; Read the packet id.
[[Sockread|sockread]] 4 &srcon.pckt.id
[[Local_Variables|var]] %srcon.pckt.id = [[$bvar]](&srcon.pckt.id, 1).long
[[dec]] %srcon.pckt.left $sockbr

; If the request id is an error, stop processing, display an error and clear the connection.
[[If-Then-Else|if]] ($srcon.inttobytes(%srcon.pckt.id) == 255 255 255 255) {
[[aline]] 04 %srcon.window * Error: Failed authentication (probably wrong password).
srcon.clear [[$sockname]]
[[return]]
}

; Read the packet command response type.
[[Sockread|sockread]] 4 &srcon.pckt.cmd
[[Local_Variables|var]] %srcon.pckt.cmd = [[$bvar]](&srcon.pckt.cmd, 1).long
[[dec]] %srcon.pckt.left $sockbr

; Read string1.
[[Sockread|sockread]] %srcon.pckt.left &srcon.pckt.string1
[[dec]] %srcon.pckt.left $sockbr
}

; If the number of bytes left to read is still positive, the packet was splitted.
; This means that we'll save the variables to globals so it can be used in the next read.
[[If-Then-Else|if]] (%srcon.pckt.left > 0) {
[[hmake]] [[$sockname]]
[[hadd]] [[$sockname]] size %srcon.pckt.size
[[hadd]] [[$sockname]] left %srcon.pckt.left
[[hadd]] [[$sockname]] id %srcon.pckt.id
[[hadd]] [[$sockname]] cmd %srcon.pckt.cmd
[[hadd]] -b [[$sockname]] string1 &srcon.pckt.string1
}
; Only if we've finished reading all the packet, display it.
; NOTE: At this point, string1 also contains string2 (the one 0x00 byte), however it doesn't matter to us
; since we're only reading the text which is terminated in string1 by a 0x00 byte.
[[If-Then-Else|elseif]] (%srcon.pckt.left == 0) {
; If the response type was an auth response, display a "connected" message.
[[If-Then-Else|if]] (%srcon.pckt.cmd == $srcon.res.auth) {
[[aline]] 12 %srcon.window Now connected!
}
; If the response type was a command response, display it.
[[If-Then-Else|elseif]] (%srcon.pckt.cmd == $srcon.res.cmd) {
; Convert the binary string1 to a usable variable.
[[Local_Variables|var]] %srcon.pckt.string1 = [[$bvar]](&srcon.pckt.string1, 1, [[$bvar]](&srcon.pckt.string1, 0)).text

; Tokenize the lines to be printed and print them.
[[tokenize]] [[$asc]]([[$lf]]) %srcon.pckt.string1
[[aline]] %srcon.window [[$$|$*]]
}
}
}

; Sockets may close on their own if not kept alive.
; In case that happens when the window is still open, the socket will be reopened.
on *:SOCKCLOSE:$([[DollarPlus|$+]]($srcon.prefix, *)): {
; Get the window name for the current game server.
[[Local_Variables|var]] %srcon.window = [[DollarPlus|$+]](@, [[$remove]]([[$sockname]], $srcon.prefix))

; If the window and the current request id still exists, reopen the socket.
[[If-Then-Else|if]] (([[$window_(remote)|$window(]]%srcon.window)) && (%srcon.id. [ [[DollarPlus|$+]] [ [[$sockname]] ] ])) {
; Save the socket details before terminating it.
%srcon.name = [[$sockname]]
%srcon.ip = [[$sock]]([[$sockname]]).ip
%srcon.port = [[$sock]]([[$sockname]]).port
%srcon.pass = [[$sock]]([[$sockname]]).mark

; Terminate the socket so it could be reopened.
[[sockclose]] [[$sockname]]

; Reopen the socket to the server.
[[sockopen]] %srcon.name %srcon.ip %srcon.port

; Mark the socket with the Rcon password.
[[sockmark]] %srcon.name %srcon.pass
}
}

; Sends user input to the server as is.
; NOTE: Commands like exit or quit will close the server!
on *:INPUT:@: {
; Get the socket name.
[[Local_Variables|var]] %srcon.socket = [[DollarPlus|$+]]($srcon.prefix, [[$remove]]($target, @))

; Check if the socket is still alive.
[[If-Then-Else|if]] (![[$sock]](%srcon.socket)) {
[[aline]] 04 $target * Error: Socket is dead. Close the window and try again.
[[return]]
}

; Build the execute command request packet and send it to the server.

; Increment the current request id.
[[inc]] %srcon.id. [[DollarPlus|$+]] %srcon.socket

; Construct the request to send to the game server.
srcon.getrequest &srcon.cmd %srcon.id. [ [[DollarPlus|$+]] [ %srcon.socket ] ] $srcon.req.execcmd [[$1-|$1-]]

[[aline]] $target -> [[$1-|$1-]]

; Send the command request.
[[sockwrite]] %srcon.socket &srcon.cmd
}

; If the user has closed the rcon window, clear the socket.
on *:CLOSE:@: {
srcon.clear [[DollarPlus|$+]]($srcon.prefix, [[$remove]]($target, @))
}

; Constructs a request with the given parameters:
; $1 = Bvar to store the request
; $2 = Request ID
; $3 = Request type
; $4- = Request data (password/command)
[[alias]] -l srcon.getrequest {
; Clear the given bvar to make sure it doesn't contain any preset values.
[[bunset]] [[$1-|$1]]

; Set the given request ID in the request.
[[bset]] [[$1-|$1]] 5 $srcon.inttobytes([[$1-|$2]])

; Set the given request type.
[[bset]] [[$1-|$1]] 9 $srcon.inttobytes([[$1-|$3]])

; Set string1 the request data.
[[bset]] -t [[$1-|$1]] 13 [[$1-|$4-]]

; Terminate string1 with 0x00 and set string2 to 0x00.
[[bset]] [[$1-|$1]] [[$calc]]([[$bvar]]([[$1-|$1]],0) + 1) 00 00

; Set the packet size.
[[bset]] [[$1-|$1]] 1 $srcon.inttobytes([[$calc]]([[$bvar]]([[$1-|$1]], 0) - 4))
}

; Clears the socket and the request id.
[[alias]] -l srcon.clear {
; If there's a socket named accordingly, close it.
[[If-Then-Else|if]] ([[$sock]]([[$1-|$1]])) {
[[sockclose]] [[$1-|$1]]
}

; Clear the id var.
[[Unset|unset]] %srcon.id. [[DollarPlus|$+]] [[$1-|$1]]
}

==See also==
* [[How to query a CS Server]]

[[Category:Tutorials]]
[[Category:Socket]]

How to RCON a source engine based server

2011-02-13T19:18:36Z

Vliedel:

; Source RCON control snippet by NaNg
; Date: 12-02-2011
; Tested on mIRC 7.14
;
; Remote control window for Source engine based games (e.g. HL2, OrangeBox, CS:S, CSP etc.),
; based on the Source RCON Protocol found at http://developer.valvesoftware.com/wiki/Source_RCON_Protocol
;
; Warning! I couldn't find a perfect way to open the socket nicely everytime it closes, so don't rely on it
; to be connected 24/7 (plus, the socket is closed on the server side every changelevel).
;
; Usage:
; * /sourcercon <ip> <port> <pass>

; Define a prefix for sockent names.
[[alias]] -l srcon.prefix { [[return]] SRcon }

; Set the command requests and response types.
[[alias]] -l srcon.req.execcmd { [[return]] 2 }
[[alias]] -l srcon.req.auth { [[return]] 3 }
[[alias]] -l srcon.res.cmd { [[return]] 0 }
[[alias]] -l srcon.res.auth { [[return]] 2 }

; Turn the given number to a 4-byte number.
[[alias]] -l srcon.inttobytes {
[[tokenize]] 46 [[$longip]]([[$1-|$1]])
[[return]] [[$1-|$4]] [[$1-|$3]] [[$1-|$2]] [[$1-|$1]]
}

; Validates arguments and tries to open the socket to the game server for authentication.
[[alias]] sourcercon {
; Validate arguments (simple, no need for full validation).
[[If-Then-Else|if]] ((![[$longip]]([[$1-|$1]])) || ([[$1-|$2]] !isnum 1-65536) || (![[$1-|$3]])) {
[[echo]] -ag Invalid parameters.
[[return]]
}

; Save the server's address.
[[Local_Variables|var]] %server.addr = [[DollarPlus|$+]]([[$1-|$1]],:,[[$1-|$2]])

; Check that the user has not opened a Rcon window for the same server already.
; This makes sure that the user won't have a Rcon step over another Rcon for the same server.
[[If-Then-Else|if]] ([[$window_(remote)|$window(]]%server.addr)) {
[[echo]] -ag Rcon window for [[$1-|$1]] is already open! close it before trying.
[[return]]
}

; Open the Rcon window whilst activating it, with an editbox, hide the @ prefix and maximize it.
window -aek0x @ [[DollarPlus|$+]] %server.addr
[[aline]] 12 @ [[DollarPlus|$+]] %server.addr Source RCON window. Type a command\cvar to send to the server, responses will be displayed here.
[[aline]] 12 @ [[DollarPlus|$+]] %server.addr Warning! commands like exit or quit will close the server! avoid using them!

; Set the socket name we'll use.
[[Local_Variables|var]] %sockname = [[DollarPlus|$+]]($srcon.prefix,%server.addr)

; Open the socket to the server.
[[sockopen]] %sockname [[$1-|$1]] [[$1-|$2]]

; Mark the socket with the Rcon password.
[[sockmark]] %sockname [[$1-|$3]]
}

; Catch all sockopens with the Source Rcon sockets prefix.
; Build the authentication request packet and send it to the server.
on *:SOCKOPEN:$([[DollarPlus|$+]]($srcon.prefix, *)): {
; Initialize the request ID for the connection.
[[set]] %srcon.id. [[DollarPlus|$+]] [[$sockname]] 0

; Constructed auth request to send to the server.
srcon.getrequest &srcon.auth %srcon.id. [ [[DollarPlus|$+]] [ [[$sockname]] ] ] $srcon.req.auth [[$sock]]([[$sockname]]).mark

; Send the authentication packet.
[[sockwrite]] [[$sockname]] &srcon.auth
}

; Read data from the game server.
on *:SOCKREAD:$([[DollarPlus|$+]]($srcon.prefix, *)): {
; Get the window name for the current game server.
[[Local_Variables|var]] %srcon.window = [[DollarPlus|$+]](@, [[$remove]]([[$sockname]], $srcon.prefix))

; If there were errors, $sockerr will tell us so.
; Write the error message to the window and clear the connection.
[[If-Then-Else|if]] ($sockerr) {
[[aline]] 04 %srcon.window * Error: Reading from socket: [[$sock]]([[$sockname]]).wsmsg
srcon.clear [[$sockname]]
[[return]]
}

; If a prior packet didn't finish receiving, continue reading it.
[[If-Then-Else|if]] ([[$hget]]([[$sockname]])) {
; Set the packet size.
[[Local_Variables|var]] %srcon.pckt.size = [[$hget]]([[$sockname]], size)

; Set the number of bytes left to read.
[[Local_Variables|var]] %srcon.pckt.left = [[$hget]]([[$sockname]], left)

; Set the request id.
[[Local_Variables|var]] %srcon.pckt.id = [[$hget]]([[$sockname]], id)

; Set the command response type.
[[Local_Variables|var]] %srcon.pckt.cmd = [[$hget]]([[$sockname]], cmd)

; Set the cut string1.
[[noop]] [[$hget]]([[$sockname]], string1, &srcon.pckt.string1)

; Read the rest of string1.
[[Sockread|sockread]] %srcon.pckt.left &srcon.pckt.rest
[[dec]] %srcon.pckt.left $sockbr

; Append the rest of string1 to the already received string1.
[[bcopy]] &srcon.pckt.string1 [[$calc]]([[$bvar]](&srcon.pckt.string1, 0) + 1) &srcon.pckt.rest 1 -1

; Clear the un-needed variables.
[[hfree]] [[$sockname]]
}
; Else, if the packet wasn't splitted.
[[If-Then-Else|else]] {
; Read the packet size.
[[Sockread|sockread]] 4 &srcon.pckt.size
[[Local_Variables|var]] %srcon.pckt.size = [[$bvar]](&srcon.pckt.size, 1).long

; Initialize the number of bytes left to read.
[[Local_Variables|var]] %srcon.pckt.left = %srcon.pckt.size

; Read the packet id.
[[Sockread|sockread]] 4 &srcon.pckt.id
[[Local_Variables|var]] %srcon.pckt.id = [[$bvar]](&srcon.pckt.id, 1).long
[[dec]] %srcon.pckt.left $sockbr

; If the request id is an error, stop processing, display an error and clear the connection.
[[If-Then-Else|if]] ($srcon.inttobytes(%srcon.pckt.id) == 255 255 255 255) {
[[aline]] 04 %srcon.window * Error: Failed authentication (probably wrong password).
srcon.clear [[$sockname]]
[[return]]
}

; Read the packet command response type.
[[Sockread|sockread]] 4 &srcon.pckt.cmd
[[Local_Variables|var]] %srcon.pckt.cmd = [[$bvar]](&srcon.pckt.cmd, 1).long
[[dec]] %srcon.pckt.left $sockbr

; Read string1.
[[Sockread|sockread]] %srcon.pckt.left &srcon.pckt.string1
[[dec]] %srcon.pckt.left $sockbr
}

; If the number of bytes left to read is still positive, the packet was splitted.
; This means that we'll save the variables to globals so it can be used in the next read.
[[If-Then-Else|if]] (%srcon.pckt.left > 0) {
[[hmake]] [[$sockname]]
[[hadd]] [[$sockname]] size %srcon.pckt.size
[[hadd]] [[$sockname]] left %srcon.pckt.left
[[hadd]] [[$sockname]] id %srcon.pckt.id
[[hadd]] [[$sockname]] cmd %srcon.pckt.cmd
[[hadd]] -b [[$sockname]] string1 &srcon.pckt.string1
}
; Only if we've finished reading all the packet, display it.
; NOTE: At this point, string1 also contains string2 (the one 0x00 byte), however it doesn't matter to us
; since we're only reading the text which is terminated in string1 by a 0x00 byte.
[[If-Then-Else|elseif]] (%srcon.pckt.left == 0) {
; If the response type was an auth response, display a "connected" message.
[[If-Then-Else|if]] (%srcon.pckt.cmd == $srcon.res.auth) {
[[aline]] 12 %srcon.window Now connected!
}
; If the response type was a command response, display it.
[[If-Then-Else|elseif]] (%srcon.pckt.cmd == $srcon.res.cmd) {
; Convert the binary string1 to a usable variable.
[[Local_Variables|var]] %srcon.pckt.string1 = [[$bvar]](&srcon.pckt.string1, 1, [[$bvar]](&srcon.pckt.string1, 0)).text

; Tokenize the lines to be printed and print them.
[[tokenize]] [[$asc]]([[$lf]]) %srcon.pckt.string1
[[aline]] %srcon.window [[$$|$*]]
}
}
}

; Sockets may close on their own if not kept alive.
; In case that happens when the window is still open, the socket will be reopened.
on *:SOCKCLOSE:$([[DollarPlus|$+]]($srcon.prefix, *)): {
; Get the window name for the current game server.
[[Local_Variables|var]] %srcon.window = [[DollarPlus|$+]](@, [[$remove]]([[$sockname]], $srcon.prefix))

; If the window and the current request id still exists, reopen the socket.
[[If-Then-Else|if]] (([[$window_(remote)|$window(]]%srcon.window)) && (%srcon.id. [ [[DollarPlus|$+]] [ [[$sockname]] ] ])) {
; Save the socket details before terminating it.
%srcon.name = [[$sockname]]
%srcon.ip = [[$sock]]([[$sockname]]).ip
%srcon.port = [[$sock]]([[$sockname]]).port
%srcon.pass = [[$sock]]([[$sockname]]).mark

; Terminate the socket so it could be reopened.
[[sockclose]] [[$sockname]]

; Reopen the socket to the server.
[[sockopen]] %srcon.name %srcon.ip %srcon.port

; Mark the socket with the Rcon password.
[[sockmark]] %srcon.name %srcon.pass
}
}

; Sends user input to the server as is.
; NOTE: Commands like exit or quit will close the server!
on *:INPUT:@: {
; Get the socket name.
[[Local_Variables|var]] %srcon.socket = [[DollarPlus|$+]]($srcon.prefix, [[$remove]]($target, @))

; Check if the socket is still alive.
[[If-Then-Else|if]] (![[$sock]](%srcon.socket)) {
[[aline]] 04 $target * Error: Socket is dead. Close the window and try again.
[[return]]
}

; Build the execute command request packet and send it to the server.

; Increment the current request id.
[[inc]] %srcon.id. [[DollarPlus|$+]] %srcon.socket

; Construct the request to send to the game server.
srcon.getrequest &srcon.cmd %srcon.id. [ [[DollarPlus|$+]] [ %srcon.socket ] ] $srcon.req.execcmd [[$1-|$1-]]

[[aline]] $target -> [[$1-|$1-]]

; Send the command request.
[[sockwrite]] %srcon.socket &srcon.cmd
}

; If the user has closed the rcon window, clear the socket.
on *:CLOSE:@: {
srcon.clear [[DollarPlus|$+]]($srcon.prefix, [[$remove]]($target, @))
}

; Constructs a request with the given parameters:
; $1 = Bvar to store the request
; $2 = Request ID
; $3 = Request type
; $4- = Request data (password/command)
[[alias]] -l srcon.getrequest {
; Clear the given bvar to make sure it doesn't contain any preset values.
[[bunset]] [[$1-|$1]]

; Set the given request ID in the request.
[[bset]] [[$1-|$1]] 5 $srcon.inttobytes([[$1-|$2]])

; Set the given request type.
[[bset]] [[$1-|$1]] 9 $srcon.inttobytes([[$1-|$3]])

; Set string1 the request data.
[[bset]] -t [[$1-|$1]] 13 [[$1-|$4-]]

; Terminate string1 with 0x00 and set string2 to 0x00.
[[bset]] [[$1-|$1]] [[$calc]]([[$bvar]]([[$1-|$1]],0) + 1) 00 00

; Set the packet size.
[[bset]] [[$1-|$1]] 1 $srcon.inttobytes([[$calc]]([[$bvar]]([[$1-|$1]], 0) - 4))
}

; Clears the socket and the request id.
[[alias]] -l srcon.clear {
; If there's a socket named accordingly, close it.
[[If-Then-Else|if]] ([[$sock]]([[$1-|$1]])) {
[[sockclose]] [[$1-|$1]]
}

; Clear the id var.
[[Unset|unset]] %srcon.id. [[DollarPlus|$+]] [[$1-|$1]]
}

==See also==
* [[How_to_query_a_CS_Server]]

[[Category:Tutorials]]
[[Category:Socket]]

How to RCON a source engine based server

2011-02-12T20:46:45Z

Vliedel: added see also

; Source RCON control snippet by NaNg
; Date: 10-02-2011
;
; Remote control window for Source engine based games (e.g. HL2, OrangeBox, CS:S, CSP etc.),
; based on the Source RCON Protocol found at http://developer.valvesoftware.com/wiki/Source_RCON_Protocol
;
; Usage:
; * /sourcercon <ip> <port> <pass>

; Define a prefix for sockent names.
[[alias]] -l srcon.prefix { [[return]] SRcon }

; Set the command requests and response types.
[[alias]] -l srcon.req.execcmd { [[return]] 2 }
[[alias]] -l srcon.req.auth { [[return]] 3 }
[[alias]] -l srcon.res.cmd { [[return]] 0 }
[[alias]] -l srcon.res.auth { [[return]] 2 }

; Turn the given number to a 4-byte number.
[[alias]] -l srcon.inttobytes {
[[tokenize]] 46 [[$longip]]([[$1-|$1]])
[[return]] [[$1-|$4]] [[$1-|$3]] [[$1-|$2]] [[$1-|$1]]
}

; Validates arguments and tries to open the socket to the game server for authentication.
[[alias]] sourcercon {
; Validate arguments (simple, no need for full validation).
[[If-Then-Else|if]] ((![[$longip]]([[$1-|$1]])) || ([[$1-|$2]] !isnum 1-65536) || (![[$1-|$3]])) {
[[echo]] -ag Invalid parameters.
[[return]]
}

; Save the server's address.
[[Local_Variables|var]] %server.addr = [[DollarPlus|$+]]([[$1-|$1]],:,[[$1-|$2]])

; Check that the user has not opened a Rcon window for the same server already.
; This makes sure that the user won't have a Rcon step over another Rcon for the same server.
[[If-Then-Else|if]] ([[$window_(remote)|$window(]]%server.addr)) {
[[echo]] -ag Rcon window for [[$1-|$1]] is already open! close it before trying.
[[return]]
}

; Open the Rcon window whilst activating it, with an editbox, hide the @ prefix and maximize it.
window -aek0x @ [[DollarPlus|$+]] %server.addr sourcercon.execcmd
[[aline]] 12 @ [[DollarPlus|$+]] %server.addr Source RCON window. If there's no error, you're connected!
[[aline]] 12 @ [[DollarPlus|$+]] %server.addr Type a command\cvar to send to the server, responses will be displayed here.
[[aline]] 12 @ [[DollarPlus|$+]] %server.addr Warning! commands like exit or quit will close the server! avoid using them!

; Set the socket name we'll use.
[[Local_Variables|var]] %sockname = [[DollarPlus|$+]]($srcon.prefix,%server.addr)

; Open the socket to the server.
[[sockopen]] %sockname [[$1-|$1]] [[$1-|$2]]

; Mark the socket with the Rcon password.
[[sockmark]] %sockname [[$1-|$3]]
}

; Catch all sockopens with the Source Rcon sockets prefix.
; Build the authentication request packet and send it to the server.
on *:SOCKOPEN:$([[DollarPlus|$+]]($srcon.prefix,*)): {
; Initialize the request ID for the connection.
[[set]] %srcon.id. [[DollarPlus|$+]] [[$sockname]] 0

; Constructed auth request to send to the server.
[[noop]] $srcon.getrequest(%srcon.id. [ [[DollarPlus|$+]] [ [[$sockname]] ] ], $srcon.req.auth, [[$sock]]([[$sockname]]).mark, &srcon.auth)

; Send the authentication packet.
[[sockwrite]] [[$sockname]] &srcon.auth
}

; Read data from the game server.
on *:SOCKREAD:$([[DollarPlus|$+]]($srcon.prefix,*)): {
; Get the window name for the current game server.
[[Local_Variables|var]] %srcon.window = [[DollarPlus|$+]](@, [[$remove]]([[$sockname]], $srcon.prefix))

; If there were errors, $sockerr will tell us so.
; Write the error message to the window and clear the connection.
[[If-Then-Else|if]] ($sockerr) {
[[aline]] 04 %srcon.window * Error: Reading from socket: [[$sock]]([[$sockname]]).wsmsg
srcon.clear [[$sockname]]
[[return]]
}

; If a prior packet didn't finish receiving, continue reading it.
[[If-Then-Else|if]] ([[$hget]]([[$sockname]])) {
; Set the packet size.
[[Local_Variables|var]] %srcon.pckt.size = [[$hget]]([[$sockname]], size)

; Set the number of bytes left to read.
[[Local_Variables|var]] %srcon.pckt.left = [[$hget]]([[$sockname]], left)

; Set the request id.
[[Local_Variables|var]] %srcon.pckt.id = [[$hget]]([[$sockname]], id)

; Set the command response type.
[[Local_Variables|var]] %srcon.pckt.cmd = [[$hget]]([[$sockname]], cmd)

; Set the cut string1.
[[noop]] [[$hget]]([[$sockname]], string1, &srcon.pckt.string1)

; Read the rest of string1.
[[Sockread|sockread]] %srcon.pckt.left &srcon.pckt.rest
[[dec]] %srcon.pckt.left $sockbr

; Append the rest of string1 to the already received string1.
[[bcopy]] &srcon.pckt.string1 [[$calc]]([[$bvar]](&srcon.pckt.string1, 0) + 1) &srcon.pckt.rest 1 -1

; Clear the un-needed variables.
[[hfree]] [[$sockname]]
}
; Else, if the packet wasn't splitted.
[[If-Then-Else|else]] {
; Read the packet size.
[[Sockread|sockread]] 4 &srcon.pckt.size
[[Local_Variables|var]] %srcon.pckt.size = [[$bvar]](&srcon.pckt.size, 1).long

; Initialize the number of bytes left to read.
[[Local_Variables|var]] %srcon.pckt.left = %srcon.pckt.size

; Read the packet id.
[[Sockread|sockread]] 4 &srcon.pckt.id
[[Local_Variables|var]] %srcon.pckt.id = [[$bvar]](&srcon.pckt.id, 1).long
[[dec]] %srcon.pckt.left $sockbr

; If the request id is an error, stop processing, display an error and clear the connection.
[[If-Then-Else|if]] ($srcon.inttobytes(%srcon.pckt.id) == 255 255 255 255) {
[[aline]] 04 %srcon.window * Error: Failed authentication (probably wrong password).
srcon.clear [[$sockname]]
[[return]]
}

; Read the packet command response type.
[[Sockread|sockread]] 4 &srcon.pckt.cmd
[[Local_Variables|var]] %srcon.pckt.cmd = [[$bvar]](&srcon.pckt.cmd, 1).long
[[dec]] %srcon.pckt.left $sockbr

; Read string1.
[[Sockread|sockread]] %srcon.pckt.left &srcon.pckt.string1
[[dec]] %srcon.pckt.left $sockbr
}

; If the number of bytes left to read is still positive, the packet was splitted.
; This means that we'll save the variables to globals so it can be used in the next read.
[[If-Then-Else|if]] (%srcon.pckt.left > 0) {
[[hmake]] [[$sockname]]
[[hadd]] [[$sockname]] size %srcon.pckt.size
[[hadd]] [[$sockname]] left %srcon.pckt.left
[[hadd]] [[$sockname]] id %srcon.pckt.id
[[hadd]] [[$sockname]] cmd %srcon.pckt.cmd
[[hadd]] -b [[$sockname]] string1 &srcon.pckt.string1
}
; Only if we've finished reading all the packet and the response type was a command response, display it.
; NOTE: At this point, string1 also contains string2 (the one 0x00 byte), however it doesn't matter to us
; since we're only reading the text which is terminated in string1 by a 0x00 byte.
[[If-Then-Else|elseif]] ((%srcon.pckt.left == 0) && (%srcon.pckt.cmd == $srcon.res.cmd)) {
; Convert the binary string1 to a usable variable.
[[Local_Variables|var]] %srcon.pckt.string1 = [[$bvar]](&srcon.pckt.string1, 1, [[$bvar]](&srcon.pckt.string1, 0)).text

; Tokenize the lines to be printed and print them.
[[tokenize]] [[$asc]]([[$lf]]) %srcon.pckt.string1
[[aline]] %srcon.window [[$$|$*]]
}
}

; Sockets may close on their own if not kept alive.
; In case that happens when the window is still open, the socket will be reopened.
on *:SOCKCLOSE:$([[DollarPlus|$+]]($srcon.prefix,*)): {
; Get the window name for the current game server.
[[Local_Variables|var]] %srcon.window = [[DollarPlus|$+]](@, [[$remove]]([[$sockname]], $srcon.prefix))

; If the window and the current request id still exists, reopen the socket.
[[If-Then-Else|if]] (([[$window_(remote)|$window(]]%srcon.window)) && (%srcon.id. [ [[DollarPlus|$+]] [ [[$sockname]] ] ])) {
; Save the socket details before terminating it.
%srcon.name = [[$sockname]]
%srcon.ip = [[$sock]]([[$sockname]]).ip
%srcon.port = [[$sock]]([[$sockname]]).port
%srcon.pass = [[$sock]]([[$sockname]]).mark

; Terminate the socket so it could be reopened.
[[sockclose]] [[$sockname]]

; Reopen the socket to the server.
[[sockopen]] %srcon.name %srcon.ip %srcon.port

; Mark the socket with the Rcon password.
[[sockmark]] %srcon.name %srcon.pass
}
}

; Sends user input to the server as is.
; NOTE: Commands like exit or quit will close the server!
on *:INPUT:@: {
; Get the socket name.
[[Local_Variables|var]] %srcon.socket = [[DollarPlus|$+]]($srcon.prefix, [[$remove]]($target, @))

; Check if the socket is still alive.
[[If-Then-Else|if]] (![[$sock]](%srcon.socket)) {
[[aline]] 04 $target * Error: Socket is dead. Close the window and try again.
[[return]]
}

; Build the execute command request packet and send it to the server.

; Increment the current request id.
[[inc]] %srcon.id. [[DollarPlus|$+]] %srcon.socket

; Construct the request to send to the game server.
[[noop]] $srcon.getrequest(%srcon.id. [ [[DollarPlus|$+]] [ %srcon.socket ] ], $srcon.req.execcmd, [[$1-|$1-]], &srcon.cmd)

[[aline]] $target -> [[$1-|$1-]]

; Send the command request.
[[sockwrite]] %srcon.socket &srcon.cmd
}

; If the user has closed the rcon window, clear the socket.
on *:CLOSE:@: {
srcon.clear [[DollarPlus|$+]]($srcon.prefix, [[$remove]]($target, @))
}

; Constructs a request with the given parameters:
; $1 = Request ID
; $2 = Request type
; $3 = Request data (password/command)
; $4 = Bvar to store the request
[[alias]] -l srcon.getrequest {
; Clear the given bvar to make sure it doesn't contain any preset values.
[[bunset]] [[$1-|$4]]

; Set the given request ID in the request.
[[bset]] [[$1-|$4]] 5 $srcon.inttobytes([[$1-|$1]])

; Set the given request type.
[[bset]] [[$1-|$4]] 9 $srcon.inttobytes([[$1-|$2]])

; Set string1 the request data.
[[bset]] -t [[$1-|$4]] 13 [[$1-|$3]]

; Terminate string1 with 0x00 and set string2 to 0x00.
[[bset]] [[$1-|$4]] [[$calc]]([[$bvar]]([[$1-|$4]],0) + 1) 00 00

; Set the packet size.
[[bset]] [[$1-|$4]] 1 $srcon.inttobytes([[$calc]]([[$bvar]]([[$1-|$4]], 0) - 4))
}

; Clears the socket and the request id.
[[alias]] -l srcon.clear {
; If there's a socket named accordingly, close it.
[[If-Then-Else|if]] ([[$sock]]([[$1-|$1]])) {
[[sockclose]] [[$1-|$1]]
}

; Clear the id var.
[[Unset|unset]] %srcon.id. [[DollarPlus|$+]] [[$1-|$1]]
}

==See also==
* [[How_to_query_a_CS_Server]]

[[Category:Tutorials]]
[[Category:Socket]]

How to query a CS Server

2011-02-12T20:43:14Z

Vliedel: added see also

How to RCON a source engine based server

2011-02-11T12:57:40Z

Vliedel:

How to RCON a source engine based server

2011-02-11T12:53:36Z

Vliedel: Created page with " ; Source RCON control snippet by NaNg ; Date: 10-02-2011 ; ; Remote control window for Source engine based games (e.g. HL2, OrangeBox, CS:S, CSP etc.), ; based on the Source..."

How to query a CS Server

2011-02-11T12:51:31Z

Vliedel: Undo revision 5530 by Vliedel (talk)

How to query a CS Server

2011-02-11T11:40:10Z

Vliedel: nang update

If you want to e.g. get the number and names of all player who are currently playing on a CS-server, you have to send a so-called "query" to this server (using UDP) and handle everything the server sends back to you. This isn't as easy as it sounds. At first, you would have to 'learn', or, at least, understand the protocol a CS-server uses (e.g. what do I have to send to the server to get a 'good' reply and what's the structure of this reply). If you want to learn more about these protocols, take a look at http://dev.kquery.com/ or http://www.valve-erc.com/srcsdk/Code/Networking/serverqueries.html or http://developer.valvesoftware.com/wiki/Server_Queries .

The following script '''echo'''s the output to your active window. You will have to modify it to be able to use it as 'bot'. It's a more complex script and you don't need to understand it (completely) to be able to use it.

; Source RCON control snippet by NaNg
; Date: 10-02-2011
;
; Remote control window for Source engine based games (e.g. HL2, OrangeBox, CS:S, CSP etc.),
; based on the Source RCON Protocol found at http://developer.valvesoftware.com/wiki/Source_RCON_Protocol
;
; Usage:
; * /sourcercon <ip> <port> <pass>

; Define a prefix for sockent names.
[[alias]] -l srcon.prefix { [[return]] SRcon }

; Set the command requests and response types.
[[alias]] -l srcon.req.execcmd { [[return]] 2 }
[[alias]] -l srcon.req.auth { [[return]] 3 }
[[alias]] -l srcon.res.cmd { [[return]] 0 }
[[alias]] -l srcon.res.auth { [[return]] 2 }

; Turn the given number to a 4-byte number.
[[alias]] -l srcon.inttobytes {
[[tokenize]] 46 [[$longip]]([[$1-|$1]])
[[return]] [[$1-|$4]] [[$1-|$3]] [[$1-|$2]] [[$1-|$1]]
}

; Validates arguments and tries to open the socket to the game server for authentication.
[[alias]] sourcercon {
; Validate arguments (simple, no need for full validation).
[[If-Then-Else|if]] ((![[$longip]]([[$1-|$1]])) || ([[$1-|$2]] !isnum 1-65536) || (![[$1-|$3]])) {
[[echo]] -ag Invalid parameters.
[[return]]
}

; Save the server's address.
[[Local_Variables|var]] %server.addr = [[DollarPlus|$+]]([[$1-|$1]],:,[[$1-|$2]])

; Check that the user has not opened a Rcon window for the same server already.
; This makes sure that the user won't have a Rcon step over another Rcon for the same server.
[[If-Then-Else|if]] ([[$window_(remote)|$window(]]%server.addr)) {
[[echo]] -ag Rcon window for [[$1-|$1]] is already open! close it before trying.
[[return]]
}

; Open the Rcon window whilst activating it, with an editbox, hide the @ prefix and maximize it.
window -aek0x @ [[DollarPlus|$+]] %server.addr sourcercon.execcmd
[[aline]] 12 @ [[DollarPlus|$+]] %server.addr Source RCON window. If there's no error, you're connected!
[[aline]] 12 @ [[DollarPlus|$+]] %server.addr Type a command\cvar to send to the server, responses will be displayed here.
[[aline]] 12 @ [[DollarPlus|$+]] %server.addr Warning! commands like exit or quit will close the server! avoid using them!

; Set the socket name we'll use.
[[Local_Variables|var]] %sockname = [[DollarPlus|$+]]($srcon.prefix,%server.addr)

; Open the socket to the server.
[[sockopen]] %sockname [[$1-|$1]] [[$1-|$2]]

; Mark the socket with the Rcon password.
[[sockmark]] %sockname [[$1-|$3]]
}

; Catch all sockopens with the Source Rcon sockets prefix.
; Build the authentication request packet and send it to the server.
on *:SOCKOPEN:$([[DollarPlus|$+]]($srcon.prefix,*)): {
; Initialize the request ID for the connection.
[[set]] %srcon.id. [[DollarPlus|$+]] [[$sockname]] 0

; Constructed auth request to send to the server.
[[noop]] $srcon.getrequest(%srcon.id. [ [[DollarPlus|$+]] [ [[$sockname]] ] ], $srcon.req.auth, [[$sock]]([[$sockname]]).mark, &srcon.auth)

; Send the authentication packet.
[[sockwrite]] [[$sockname]] &srcon.auth
}

; Read data from the game server.
on *:SOCKREAD:$([[DollarPlus|$+]]($srcon.prefix,*)): {
; Get the window name for the current game server.
[[Local_Variables|var]] %srcon.window = [[DollarPlus|$+]](@, [[$remove]]([[$sockname]], $srcon.prefix))

; If there were errors, $sockerr will tell us so.
; Write the error message to the window and clear the connection.
[[If-Then-Else|if]] ($sockerr) {
[[aline]] 04 %srcon.window * Error: Reading from socket: [[$sock]]([[$sockname]]).wsmsg
srcon.clear [[$sockname]]
[[return]]
}

; If a prior packet didn't finish receiving, continue reading it.
[[If-Then-Else|if]] ([[$hget]]([[$sockname]])) {
; Set the packet size.
[[Local_Variables|var]] %srcon.pckt.size = [[$hget]]([[$sockname]], size)

; Set the number of bytes left to read.
[[Local_Variables|var]] %srcon.pckt.left = [[$hget]]([[$sockname]], left)

; Set the request id.
[[Local_Variables|var]] %srcon.pckt.id = [[$hget]]([[$sockname]], id)

; Set the command response type.
[[Local_Variables|var]] %srcon.pckt.cmd = [[$hget]]([[$sockname]], cmd)

; Set the cut string1.
[[noop]] [[$hget]]([[$sockname]], string1, &srcon.pckt.string1)

; Read the rest of string1.
[[Sockread|sockread]] %srcon.pckt.left &srcon.pckt.rest
[[dec]] %srcon.pckt.left $sockbr

; Append the rest of string1 to the already received string1.
[[bcopy]] &srcon.pckt.string1 [[$calc]]([[$bvar]](&srcon.pckt.string1, 0) + 1) &srcon.pckt.rest 1 -1

; Clear the un-needed variables.
[[hfree]] [[$sockname]]
}
; Else, if the packet wasn't splitted.
[[If-Then-Else|else]] {
; Read the packet size.
[[Sockread|sockread]] 4 &srcon.pckt.size
[[Local_Variables|var]] %srcon.pckt.size = [[$bvar]](&srcon.pckt.size, 1).long

; Initialize the number of bytes left to read.
[[Local_Variables|var]] %srcon.pckt.left = %srcon.pckt.size

; Read the packet id.
[[Sockread|sockread]] 4 &srcon.pckt.id
[[Local_Variables|var]] %srcon.pckt.id = [[$bvar]](&srcon.pckt.id, 1).long
[[dec]] %srcon.pckt.left $sockbr

; If the request id is an error, stop processing, display an error and clear the connection.
[[If-Then-Else|if]] ($srcon.inttobytes(%srcon.pckt.id) == 255 255 255 255) {
[[aline]] 04 %srcon.window * Error: Failed authentication (probably wrong password).
srcon.clear [[$sockname]]
[[return]]
}

; Read the packet command response type.
[[Sockread|sockread]] 4 &srcon.pckt.cmd
[[Local_Variables|var]] %srcon.pckt.cmd = [[$bvar]](&srcon.pckt.cmd, 1).long
[[dec]] %srcon.pckt.left $sockbr

; Read string1.
[[Sockread|sockread]] %srcon.pckt.left &srcon.pckt.string1
[[dec]] %srcon.pckt.left $sockbr
}

; If the number of bytes left to read is still positive, the packet was splitted.
; This means that we'll save the variables to globals so it can be used in the next read.
[[If-Then-Else|if]] (%srcon.pckt.left > 0) {
[[hmake]] [[$sockname]]
[[hadd]] [[$sockname]] size %srcon.pckt.size
[[hadd]] [[$sockname]] left %srcon.pckt.left
[[hadd]] [[$sockname]] id %srcon.pckt.id
[[hadd]] [[$sockname]] cmd %srcon.pckt.cmd
[[hadd]] -b [[$sockname]] string1 &srcon.pckt.string1
}
; Only if we've finished reading all the packet and the response type was a command response, display it.
; NOTE: At this point, string1 also contains string2 (the one 0x00 byte), however it doesn't matter to us
; since we're only reading the text which is terminated in string1 by a 0x00 byte.
[[If-Then-Else|elseif]] ((%srcon.pckt.left == 0) && (%srcon.pckt.cmd == $srcon.res.cmd)) {
; Convert the binary string1 to a usable variable.
[[Local_Variables|var]] %srcon.pckt.string1 = [[$bvar]](&srcon.pckt.string1, 1, [[$bvar]](&srcon.pckt.string1, 0)).text

; Tokenize the lines to be printed and print them.
[[tokenize]] [[$asc]]([[$lf]]) %srcon.pckt.string1
[[aline]] %srcon.window [[$$|$*]]
}
}

; Sockets may close on their own if not kept alive.
; In case that happens when the window is still open, the socket will be reopened.
on *:SOCKCLOSE:$([[DollarPlus|$+]]($srcon.prefix,*)): {
; Get the window name for the current game server.
[[Local_Variables|var]] %srcon.window = [[DollarPlus|$+]](@, [[$remove]]([[$sockname]], $srcon.prefix))

; If the window and the current request id still exists, reopen the socket.
[[If-Then-Else|if]] (([[$window_(remote)|$window(]]%srcon.window)) && (%srcon.id. [ [[DollarPlus|$+]] [ [[$sockname]] ] ])) {
; Save the socket details before terminating it.
%srcon.name = [[$sockname]]
%srcon.ip = [[$sock]]([[$sockname]]).ip
%srcon.port = [[$sock]]([[$sockname]]).port
%srcon.pass = [[$sock]]([[$sockname]]).mark

; Terminate the socket so it could be reopened.
[[sockclose]] [[$sockname]]

; Reopen the socket to the server.
[[sockopen]] %srcon.name %srcon.ip %srcon.port

; Mark the socket with the Rcon password.
[[sockmark]] %srcon.name %srcon.pass
}
}

; Sends user input to the server as is.
; NOTE: Commands like exit or quit will close the server!
on *:INPUT:@: {
; Get the socket name.
[[Local_Variables|var]] %srcon.socket = [[DollarPlus|$+]]($srcon.prefix, [[$remove]]($target, @))

; Check if the socket is still alive.
[[If-Then-Else|if]] (![[$sock]](%srcon.socket)) {
[[aline]] 04 $target * Error: Socket is dead. Close the window and try again.
[[return]]
}

; Build the execute command request packet and send it to the server.

; Increment the current request id.
[[inc]] %srcon.id. [[DollarPlus|$+]] %srcon.socket

; Construct the request to send to the game server.
[[noop]] $srcon.getrequest(%srcon.id. [ [[DollarPlus|$+]] [ %srcon.socket ] ], $srcon.req.execcmd, [[$1-|$1-]], &srcon.cmd)

[[aline]] $target -> [[$1-|$1-]]

; Send the command request.
[[sockwrite]] %srcon.socket &srcon.cmd
}

; If the user has closed the rcon window, clear the socket.
on *:CLOSE:@: {
srcon.clear [[DollarPlus|$+]]($srcon.prefix, [[$remove]]($target, @))
}

; Constructs a request with the given parameters:
; $1 = Request ID
; $2 = Request type
; $3 = Request data (password/command)
; $4 = Bvar to store the request
[[alias]] -l srcon.getrequest {
; Clear the given bvar to make sure it doesn't contain any preset values.
[[bunset]] [[$1-|$4]]

; Set the given request ID in the request.
[[bset]] [[$1-|$4]] 5 $srcon.inttobytes([[$1-|$1]])

; Set the given request type.
[[bset]] [[$1-|$4]] 9 $srcon.inttobytes([[$1-|$2]])

; Set string1 the request data.
[[bset]] -t [[$1-|$4]] 13 [[$1-|$3]]

; Terminate string1 with 0x00 and set string2 to 0x00.
[[bset]] [[$1-|$4]] [[$calc]]([[$bvar]]([[$1-|$4]],0) + 1) 00 00

; Set the packet size.
[[bset]] [[$1-|$4]] 1 $srcon.inttobytes([[$calc]]([[$bvar]]([[$1-|$4]], 0) - 4))
}

; Clears the socket and the request id.
[[alias]] -l srcon.clear {
; If there's a socket named accordingly, close it.
[[If-Then-Else|if]] ([[$sock]]([[$1-|$1]])) {
[[sockclose]] [[$1-|$1]]
}

; Clear the id var.
[[Unset|unset]] %srcon.id. [[DollarPlus|$+]] [[$1-|$1]]
}

[[Category:Tutorials]]
[[Category:Socket]]

Wikify

2011-02-03T13:38:27Z

Vliedel: script fucked up itsself

Script to add links to a script for this wiki.

; $1 = file
[[alias]] wikify {
[[If-Then-Else|if]] ($fopen(in)) { .[[fclose]] in }
[[If-Then-Else|if]] ($fopen(out)) { .[[fclose]] out }
.[[fopen]] in [[$1-|$1]]
[[If-Then-Else|if]] ($ferr) { [[echo]] -ag Couldn't open [[$1-|$1]] | [[return]] }
.[[fopen]] -no out wiki.txt
[[If-Then-Else|if]] ($ferr) { [[echo]] -ag Couldn't open wiki.txt | [[return]] }
[[Local_Variables|var]] %comment
[[while]] (!$fopen(in).eof) {
[[bunset]] &line
[[set]] -l %r $fread(in)
[[If-Then-Else|if]] ([[$len]](%r)) {
[[If-Then-Else|if]] ([[$left]]([[$strip]](%r),2) == /*) { [[Local_Variables|var]] %comment = 1 }
[[If-Then-Else|elseif]] ([[$left]]([[$strip]](%r),2) == */) { [[Local_Variables|var]] %comment = 0 }
[[If-Then-Else|if]] ([[$left]]([[$strip]](%r),1) != ;) && (!%comment) {
[[set]] -l %r [[$regsubex]](two,[[$regsubex]](one,%r,/((?:^\s*|\x7B\s+|\x7C\s+)[.!]*(?:while|(?:else\s*)?if)\s+)($(?>[^()]|(?2))*$)(\s+)(\S+)/g,\1\2\3 [[DollarPlus|$+]] $makelink(\4)),/(^\s*|\x7B\s+|\x7C\s+)((?:[.!]*else\s+|[.!]*timer\S*\s+(?:-\w+\s+)?(?:\d\d?:\d\d(?::\d\d)?\s+)?\d+\s+\d+\s+)?[^\s\x7B]+)/g,\1 [[DollarPlus|$+]] $makelink(\2))
[[set]] -l %r [[$regsubex]](%r,/(?<=^|\s|\x28|!|\x2C)(\$[^\s\x2C]+\x28?|\$\x28)/g,$makelink2(\1))
}
[[bset]] &line 2 [[$regsubex]](%r,/(.)/g,[[$asc]](\1) [[DollarPlus|$+]] [[$chr]](32))
}
[[bset]] &line 1 32
.[[fwrite]] -bn out &line
}
.[[fclose]] in
.[[fclose]] out
[[run]] wiki.txt
}

; $1 = command
[[alias]] -l makelink {
[[Local_Variables|var]] %c = [[$regsubex]]([[$1-|$1]],/^([.!]+)(.+),\2) , %dot = [[$regml]](1)
[[If-Then-Else|if]] ([[$read]](commands.txt,nw,%c *)) { [[return]] [[DollarPlus|$+]](%dot,[[$chr]](91),[[$chr]](91),[[$iif]]([[$gettok]]([[$v1]],2,32) == %c,%c,[[DollarPlus|$+]]([[$v1]],[[$chr]](124),%c)),[[$chr]](93),[[$chr]](93)) }
[[return]] [[$1-|$1]]
}

; $1 = $identifier(
[[alias]] -l makelink2 {
; echo -ag id: $1
; check for $!bla and $$bla and $$!bla
[[Local_Variables|var]] %id = [[$1-|$1]] , %ex , %dbl , %br , %ret , %link , %n
[[If-Then-Else|if]] ([[$mid]](%id,2,1) == $) { [[Local_Variables|var]] %id = $ [[DollarPlus|$+]] [[$right]](%id,-2) , %dbl = 1 }
[[If-Then-Else|if]] ([[$mid]](%id,2,1) == !) { [[Local_Variables|var]] %id = $ [[DollarPlus|$+]] [[$right]](%id,-2) , %ex = 1 }
[[If-Then-Else|if]] ([[$mid]](%id,2,1) isnum 1-) { [[Local_Variables|var]] %n = %id , %id = [[$!]][[$1-|1]] }
[[If-Then-Else|if]] ([[$read]](identifiers.txt,nw,%id *)) { [[Local_Variables|var]] %link = [[$gettok]]([[$v1]],2,32) }
[[If-Then-Else|elseif]] ([[$right]](%id,1) == [[$chr]](40)) {
[[Local_Variables|var]] %id = [[$left]](%id,-1) , %br = 1
[[If-Then-Else|if]] ([[$read]](identifiers.txt,nw,%id *)) { [[Local_Variables|var]] %link = [[$gettok]]([[$v1]],2,32) }
[[If-Then-Else|elseif]] ([[$read]](identifiers.txt,nw,%id [[DollarPlus|$+]] *)) { [[Local_Variables|var]] %link = [[$gettok]]([[$v1]],2,32) }
}
[[If-Then-Else|elseif]] ([[$read]](identifiers.txt,nw,%id [[DollarPlus|$+]] *)) { [[Local_Variables|var]] %link = [[$gettok]]([[$v1]],2,32) }
[[If-Then-Else|if]] (%link == [[$null]]) { [[return]] [[$1-|$1]] }
[[Local_Variables|var]] %link = [[$iif]]((%link != %id) || (%n),%link [[DollarPlus|$+]] [[$chr]](124)) , %id = [[$iif]](%n,%n,%id)
[[If-Then-Else|if]] (%dbl) { [[Local_Variables|var]] %ret = [[DollarPlus|$+]]([[$chr]](91),[[$chr]](91),[[$$]],[[$chr]](93),[[$chr]](93),[[$iif]](%ex,[[DollarPlus|$+]]([[$chr]](91),[[$chr]](91),!,[[$chr]](93),[[$chr]](93)))) }
[[If-Then-Else|elseif]] (%ex) { [[Local_Variables|var]] %ret = [[DollarPlus|$+]]([[$chr]](91),[[$chr]](91),$,!,[[$chr]](93),[[$chr]](93)) }
; echo -ag return: $+(%ret,$chr(91),$chr(91),%link,$iif(%dbl || %ex,$right(%id,-1),%id),$chr(93),$chr(93),$iif(%br,$chr(40)))
[[return]] [[DollarPlus|$+]](%ret,[[$chr]](91),[[$chr]](91),%link,[[$iif]](%dbl || %ex,[[$right]](%id,-1),%id),[[$chr]](93),[[$chr]](93),[[$iif]](%br,[[$chr]](40)))
}

commands.txt
Abook Abook
Ajinvite Ajinvite
Alias Alias
Aline Aline
Ame Ame
Amsg Amsg
Anick Anick
Aop Aop
Auser Auser
Autojoin Autojoin
Avoice Avoice
Background Background
Ban Ban
Bcopy Bcopy
Beep Beep
Bread Bread
Break Break
Breplace Breplace
Bset Bset
Btrunc Btrunc
Bunset Bunset
Bwrite Bwrite
Channel Channel
Clear Clear
Clearall Clearall
Clipboard Clipboard
Close Close
Cnick Cnick
Color Color
Continue Continue
Copy Copy
Ctcp Ctcp
Ctcpreply Ctcpreply
Ctcps Ctcps
Dde Dde
Ddeserver Ddeserver
Debug Debug
Dec Dec
Describe Describe
Did Did
Disconnect Disconnect
Dlevel Dlevel
Dns Dns
Dqwindow Dqwindow
Ebeeps Ebeeps
Echo Echo
Editbox Editbox
Else If-Then-Else
Elseif If-Then-Else
Emailaddr Emailaddr
Enable Enable
Events Events
Exit Exit
Fclose Fclose
Filter Filter
Findtext Findtext
Firewall Firewall
Flash Flash
Flist Flist
Flood Flood
Flush Flush
Flushini Flushini
Fopen Fopen
Fseek Fseek
Fullname Fullname
Fwrite Fwrite
Goto Goto
Groups Groups
Guser Guser
Hadd Hadd
Haltdef Haltdef
Hdec Hdec
Hdel Hdel
Help Help
Hfree Hfree
Hinc Hinc
Hload Hload
Hmake Hmake
Hop Hop
Hsave Hsave
Ial Ial
Ialclear Ialclear
Ialmark Ialmark
If If-Then-Else
Ignore Ignore
Inc Inc
Iuser Iuser
Join Join
Linesep Linesep
Load Load
Loadbuf Loadbuf
Localinfo Localinfo
Log Log
Menubar Menubar
Mkdir Mkdir
Mnick Mnick
Msg Msg
Noop Noop
Notify Notify
Omsg Omsg
Onotice Onotice
Partall Partall
Play Play
Pop Pop
Protect Protect
Pvoice Pvoice
Qme Qme
Qmsg Qmsg
Query Query
Queryrn Queryrn
Remini Remini
Remote Remote
Remove Remove
Rename Rename
Resetidle Resetidle
Return Return
Rlevel Rlevel
Rmdir Rmdir
Run Run
Ruser Ruser
Save Save
Saveini Saveini
Say Say
Server Server
Set Set
Setlayer Setlayer
Signal Signal
Sockaccept Sockaccept
Sockclose Sockclose
Socklist Socklist
Socklisten Socklisten
Sockmark Sockmark
Sockopen Sockopen
Sockread Sockread
Sockrename Sockrename
Sockudp Sockudp
Sockwrite Sockwrite
Speak Speak
Switchbar Switchbar
Timer Timer
Timers Timers
Timestamp Timestamp
Titlebar Titlebar
Tnick Tnick
Tokenize Tokenize
Toolbar Toolbar
Treebar Treebar
Ulist Ulist
Unset Unset
Unsetall Unsetall
Updatenl Updatenl
Userhost Userhost
Uwho Uwho
Var Local_Variables
Vol Vol
While While loops
Winhelp Winhelp
Write Write
Writeini Writeini

identifiers.txt
$$ $$
$& $&
$* $*
$0 $0
$1 $1-
$abook $abook
$abs $abs
$acos $acos
$active $active
$activecid $activecid
$activewid $activewid
$adate $adate
$address( $address_(nick)
$address $address_(remote)
$addtok $addtok
$addtokcs $addtokcs
$agent $agent
$agentname $agentname
$agentstat $agentstat
$agentver $agentver
$alias $alias
$and $and
$anick $anick
$aop $aop
$appactive $appactive
$appstate $appstate
$asc $asc
$asctime $asctime
$asin $asin
$atan $atan
$avoice $avoice
$away $away
$awaymsg $awaymsg
$awaytime $awaytime
$base $base
$beta $beta
$bfind $bfind
$bitoff $bitoff
$biton $biton
$bits $bits
$bvar $bvar
$bytes $bytes
$calc $calc
$cb $cb
$cd $cd
$ceil $ceil
$chan( $chan_(window)
$chan $chan_(remote)
$chanmodes $chanmodes
$chantypes $chantypes
$chat $chat
$chr $chr
$cid $cid
$clevel $clevel
$click $click
$cmdbox $cmdbox
$cmdline $cmdline
$cnick $cnick
$color $color
$comchan $comchan
$compact $compact
$cos $cos
$count $count
$cr $cr
$crc $crc
$crlf $crlf
$ctime $ctime
$ctrlenter $ctrlenter
$date $date
$day $day
$daylight $daylight
$dde $dde
$ddename $ddename
$decode $decode
$deltok $deltok
$devent $devent
$dialog $dialog
$did $did
$disk $disk
$dlevel $dlevel
$dname $dname
$duration $duration
$ebeeps $ebeeps
$editbox $editbox
$encode $encode
$error $error
$eval $eval
$evalnext $evalnext
$exists $exists
$file $file
$filename $filename
$filtered $filtered
$finddir $finddir
$finddirn $finddirn
$findfile $findfile
$findfilen $findfilen
$findtok $findtok
$findtokcs $findtokcs
$fline $fline
$floor $floor
$fserve $fserve
$fulldate $fulldate
$fullname $fullname
$fullscreen $fullscreen
$getdir $getdir
$getdot $getdot
$gettok $gettok
$gmt $gmt
$hfind $hfind
$hget $hget
$highlight $highlight
$hnick $hnick
$host $host
$hotline $hotline
$hotlinepos $hotlinepos
$ial $ial
$ibl $ibl
$idle $idle
$iel $iel
$ifmatch $ifmatch
$ignore $ignore
$iif $iif
$iil $iil
$inellipse $inellipse
$ini $ini
$inpoly $inpoly
$inrect $inrect
$inroundrect $inroundrect
$insong $insong
$instok $instok
$int $int
$ip $ip
$isalias $isalias
$isbit $isbit
$isdde $isdde
$isdir $isdir
$isfile $isfile
$isid $isid
$islower $islower
$istok $istok
$istokcs $istokcs
$isupper $isupper
$lactivecid $lactivecid
$left $left
$len $len
$level $level
$lf $lf
$line $line
$lines $lines
$lock $lock
$locked $locked
$log $log
$logdir $logdir
$logstamp $logstamp
$logstampfmt $logstampfmt
$longfn $longfn
$longip $longip
$lower $lower
$maddress $maddress
$mask $mask
$matchtok $matchtok
$matchtokcs $matchtokcs
$md5 $md5
$me $me
$menubar $menubar
$mid $mid
$mircdir $mircdir
$mircexe $mircexe
$mircini $mircini
$mklogfn $mklogfn
$mklogfn $mklogfn
$mnick $mnick
$mode $mode
$modespl $modespl
$mouse $mouse
$msfile $msfile
$network $network
$nick( $nick_(nick)
$nick $nick_(remote)
$nofile $nofile
$nopath $nopath
$not $not
$notags $notags
$notify $notify
$null $null
$numtok $numtok
$online $online
$onpoly $onpoly
$opnick $opnick
$or $or
$ord $ord
$os $os
$pi $pi
$pi $pi
$pic $pic
$play $play
$port $port
$portable $portable
$portfree $portfree
$pos $pos
$prefix $prefix
$prop $prop
$protect $protect
$puttok $puttok
$qt $qt
$rand $rand
$rawmsg $rawmsg
$read $read
$readini $readini
$readn $readn
$regex $regex
$regml $regml
$regsub $regsub
$regsubex $regsubex
$remote $remote
$remove $remove
$remtok $remtok
$remtokcs $remtokcs
$replace $replace
$replacecs $replacecs
$replacex $replacex
$replacexcs $replacexcs
$reptok $reptok
$reptokcs $reptokcs
$result $result
$rgb $rgb
$right $right
$round $round
$scid $scid
$scon $scon
$scriptdir $scriptdir
$sdir $sdir
$server $server
$serverip $serverip
$sfile $sfile
$sha1 $sha1
$shortfn $shortfn
$show $show
$signal $signal
$sin $sin
$sline $sline
$snick $snick
$snicks $snicks
$snotify $snotify
$sock $sock
$sockname $sockname
$sorttok $sorttok
$sorttokcs $sorttokcs
$sqrt $sqrt
$ssl $ssl
$sslready $sslready
$status $status
$str $str
$strip $strip
$style $style
$submenu $submenu
$switchbar $switchbar
$tan $tan
$ticks $ticks
$time $time
$timestamp $timestamp
$timestampfmt $timestampfmt
$timezone $timezone
$tip $tip
$toolbar $toolbar
$treebar $treebar
$true $true
$trust $trust
$ulevel $ulevel
$ulist $ulist
$upper $upper
$uptime $uptime
$v1 $v1
$v2 $v1
$version $version
$vnick $vnick
$vol $vol
$width $width
$wildtok $wildtok
$wildtokcs $wildtokcs
$window( $window_(remote)
$window $window_(picwin)
$wrap $wrap
$xor $xor
$+ DollarPlus

Wikify

2011-02-03T13:31:33Z

Vliedel:

Script to add links to a script for this wiki.

; $1 = file
[[alias]] wikify {
[[If-Then-Else|if]] ($fopen(in)) { .[[fclose]] in }
[[If-Then-Else|if]] ($fopen(out)) { .[[fclose]] out }
.[[fopen]] in [[$1-|$1]]
[[If-Then-Else|if]] ($ferr) { [[echo]] -ag Couldn't open [[$1-|$1]] | [[return]] }
.[[fopen]] -no out wiki.txt
[[If-Then-Else|if]] ($ferr) { [[echo]] -ag Couldn't open wiki.txt | [[return]] }
[[Local_Variables|var]] %comment
[[while]] (!$fopen(in).eof) {
[[bunset]] &line
[[set]] -l %r $fread(in)
[[If-Then-Else|if]] ([[$len]](%r)) {
[[If-Then-Else|if]] ([[$left]]([[$strip]](%r),2) == /*) { [[Local_Variables|var]] %comment = 1 }
[[If-Then-Else|elseif]] ([[$left]]([[$strip]](%r),2) == */) { [[Local_Variables|var]] %comment = 0 }
[[If-Then-Else|if]] ([[$left]]([[$strip]](%r),1) != ;) && (!%comment) {
[[set]] -l %r [[$regsubex]](two,[[$regsubex]](one,%r,/((?:^\s*|\x7B\s+|\x7C\s+)[.!]*(?:while|(?:else\s*)?if)\s+)($(?>[^()]|(?2))*$)(\s+)(\S+)/g,\1\2\3 [[DollarPlus|$+]] $makelink(\4)),/(^\s*|\x7B\s+|\x7C\s+)((?:[.!]*else\s+|[.!]*timer\S*\s+(?:-\w+\s+)?(?:\d\d?:\d\d(?::\d\d)?\s+)?\d+\s+\d+\s+)?[^\s\x7B]+)/g,\1 [[DollarPlus|$+]] $makelink(\2))
[[set]] -l %r [[$regsubex]](%r,/(?<=^|\s|\x28|!|\x2C)(\$[^\s\x2C]+\x28?|\$\x28)/g,$makelink2(\1))

}
[[bset]] &line 2 [[$regsubex]](%r,/(.)/g,[[$asc]](\1) [[DollarPlus|$+]] [[$chr]](32))
}
[[bset]] &line 1 32
.[[fwrite]] -bn out &line
}
.[[fclose]] in
.[[fclose]] out
[[run]] wiki.txt
}

; $1 = command
[[alias]] -l makelink {
[[Local_Variables|var]] %c = [[$regsubex]]([[$1-|$1]],/^([.!]+)(.+),\2) , %dot = [[$regml]](1)
[[If-Then-Else|if]] ([[$read]](commands.txt,nw,%c *)) { [[return]] [[DollarPlus|$+]](%dot,[[$chr]](91),[[$chr]](91),[[$iif]]([[$gettok]]([[$v1]],2,32) == %c,%c,[[DollarPlus|$+]]([[$v1]],[[$chr]](124),%c)),[[$chr]](93),[[$chr]](93)) }
[[return]] [[$1-|$1]]
}

; $1 = $identifier(
[[alias]] -l makelink2 {
; echo -ag id: $1
; check for $!bla and $$bla and $$!bla
[[Local_Variables|var]] %id = [[$1-|$1]] , %ex , %dbl , %br , %ret , %link , %n
[[If-Then-Else|if]] ([[$mid]](%id,2,1) == $) { [[Local_Variables|var]] %id = $ [[DollarPlus|$+]] [[$right]](%id,-2) , %dbl = 1 }
[[If-Then-Else|if]] ([[$mid]](%id,2,1) == !) { [[Local_Variables|var]] %id = $ [[DollarPlus|$+]] [[$right]](%id,-2) , %ex = 1 }
[[If-Then-Else|if]] ([[$mid]](%id,2,1) isnum 1-) { [[Local_Variables|var]] %n = %id , %id = [[$!]][[$1-|1]] }
[[If-Then-Else|if]] ([[$read]](identifiers.txt,nw,%id *)) { [[Local_Variables|var]] %link = [[$gettok]]([[$v1]],2,32) }
[[If-Then-Else|elseif]] ([[$right]](%id,1) == [[$chr]](40)) {
[[Local_Variables|var]] %id = [[$left]](%id,-1) , %br = 1
[[If-Then-Else|if]] ([[$read]](identifiers.txt,nw,%id *)) { [[Local_Variables|var]] %link = [[$gettok]]([[$v1]],2,32) }
[[If-Then-Else|elseif]] ([[$read]](identifiers.txt,nw,%id [[DollarPlus|$+]] *)) { [[Local_Variables|var]] %link = [[$gettok]]([[$v1]],2,32) }
}
[[If-Then-Else|elseif]] ([[$read]](identifiers.txt,nw,%id [[DollarPlus|$+]] *)) { [[Local_Variables|var]] %link = [[$gettok]]([[$v1]],2,32) }
[[If-Then-Else|if]] (%link == [[$null]]) { [[return]] [[$1-|$1]] }
[[Local_Variables|var]] %link = [[$iif]]((%link != %id) || (%n),%link [[DollarPlus|$+]] [[$chr]](124)) , %id = [[$iif]](%n,%n,%id)
[[If-Then-Else|if]] (%dbl) { [[Local_Variables|var]] %ret = [[DollarPlus|$+]]([[$chr]](91),[[$chr]](91),[[$$]][[$$|]],[[$chr]](93),[[$chr]](93),[[$iif]](%ex,[[DollarPlus|$+]]([[$chr]](91),[[$chr]](91),!,[[$chr]](93),[[$chr]](93)))) }
[[If-Then-Else|elseif]] (%ex) { [[Local_Variables|var]] %ret = [[DollarPlus|$+]]([[$chr]](91),[[$chr]](91),$,!,[[$chr]](93),[[$chr]](93)) }
; echo -ag return: $+(%ret,$chr(91),$chr(91),%link,$iif(%dbl || %ex,$right(%id,-1),%id),$chr(93),$chr(93),$iif(%br,$chr(40)))
[[return]] [[DollarPlus|$+]](%ret,[[$chr]](91),[[$chr]](91),%link,[[$iif]](%dbl || %ex,[[$right]](%id,-1),%id),[[$chr]](93),[[$chr]](93),[[$iif]](%br,[[$chr]](40)))
}

commands.txt
Abook Abook
Ajinvite Ajinvite
Alias Alias
Aline Aline
Ame Ame
Amsg Amsg
Anick Anick
Aop Aop
Auser Auser
Autojoin Autojoin
Avoice Avoice
Background Background
Ban Ban
Bcopy Bcopy
Beep Beep
Bread Bread
Break Break
Breplace Breplace
Bset Bset
Btrunc Btrunc
Bunset Bunset
Bwrite Bwrite
Channel Channel
Clear Clear
Clearall Clearall
Clipboard Clipboard
Close Close
Cnick Cnick
Color Color
Continue Continue
Copy Copy
Ctcp Ctcp
Ctcpreply Ctcpreply
Ctcps Ctcps
Dde Dde
Ddeserver Ddeserver
Debug Debug
Dec Dec
Describe Describe
Did Did
Disconnect Disconnect
Dlevel Dlevel
Dns Dns
Dqwindow Dqwindow
Ebeeps Ebeeps
Echo Echo
Editbox Editbox
Else If-Then-Else
Elseif If-Then-Else
Emailaddr Emailaddr
Enable Enable
Events Events
Exit Exit
Fclose Fclose
Filter Filter
Findtext Findtext
Firewall Firewall
Flash Flash
Flist Flist
Flood Flood
Flush Flush
Flushini Flushini
Fopen Fopen
Fseek Fseek
Fullname Fullname
Fwrite Fwrite
Goto Goto
Groups Groups
Guser Guser
Hadd Hadd
Haltdef Haltdef
Hdec Hdec
Hdel Hdel
Help Help
Hfree Hfree
Hinc Hinc
Hload Hload
Hmake Hmake
Hop Hop
Hsave Hsave
Ial Ial
Ialclear Ialclear
Ialmark Ialmark
If If-Then-Else
Ignore Ignore
Inc Inc
Iuser Iuser
Join Join
Linesep Linesep
Load Load
Loadbuf Loadbuf
Localinfo Localinfo
Log Log
Menubar Menubar
Mkdir Mkdir
Mnick Mnick
Msg Msg
Noop Noop
Notify Notify
Omsg Omsg
Onotice Onotice
Partall Partall
Play Play
Pop Pop
Protect Protect
Pvoice Pvoice
Qme Qme
Qmsg Qmsg
Query Query
Queryrn Queryrn
Remini Remini
Remote Remote
Remove Remove
Rename Rename
Resetidle Resetidle
Return Return
Rlevel Rlevel
Rmdir Rmdir
Run Run
Ruser Ruser
Save Save
Saveini Saveini
Say Say
Server Server
Set Set
Setlayer Setlayer
Signal Signal
Sockaccept Sockaccept
Sockclose Sockclose
Socklist Socklist
Socklisten Socklisten
Sockmark Sockmark
Sockopen Sockopen
Sockread Sockread
Sockrename Sockrename
Sockudp Sockudp
Sockwrite Sockwrite
Speak Speak
Switchbar Switchbar
Timer Timer
Timers Timers
Timestamp Timestamp
Titlebar Titlebar
Tnick Tnick
Tokenize Tokenize
Toolbar Toolbar
Treebar Treebar
Ulist Ulist
Unset Unset
Unsetall Unsetall
Updatenl Updatenl
Userhost Userhost
Uwho Uwho
Var Local_Variables
Vol Vol
While While loops
Winhelp Winhelp
Write Write
Writeini Writeini

identifiers.txt
$$ $$
$& $&
$* $*
$0 $0
$1 $1-
$abook $abook
$abs $abs
$acos $acos
$active $active
$activecid $activecid
$activewid $activewid
$adate $adate
$address( $address_(nick)
$address $address_(remote)
$addtok $addtok
$addtokcs $addtokcs
$agent $agent
$agentname $agentname
$agentstat $agentstat
$agentver $agentver
$alias $alias
$and $and
$anick $anick
$aop $aop
$appactive $appactive
$appstate $appstate
$asc $asc
$asctime $asctime
$asin $asin
$atan $atan
$avoice $avoice
$away $away
$awaymsg $awaymsg
$awaytime $awaytime
$base $base
$beta $beta
$bfind $bfind
$bitoff $bitoff
$biton $biton
$bits $bits
$bvar $bvar
$bytes $bytes
$calc $calc
$cb $cb
$cd $cd
$ceil $ceil
$chan( $chan_(window)
$chan $chan_(remote)
$chanmodes $chanmodes
$chantypes $chantypes
$chat $chat
$chr $chr
$cid $cid
$clevel $clevel
$click $click
$cmdbox $cmdbox
$cmdline $cmdline
$cnick $cnick
$color $color
$comchan $comchan
$compact $compact
$cos $cos
$count $count
$cr $cr
$crc $crc
$crlf $crlf
$ctime $ctime
$ctrlenter $ctrlenter
$date $date
$day $day
$daylight $daylight
$dde $dde
$ddename $ddename
$decode $decode
$deltok $deltok
$devent $devent
$dialog $dialog
$did $did
$disk $disk
$dlevel $dlevel
$dname $dname
$duration $duration
$ebeeps $ebeeps
$editbox $editbox
$encode $encode
$error $error
$eval $eval
$evalnext $evalnext
$exists $exists
$file $file
$filename $filename
$filtered $filtered
$finddir $finddir
$finddirn $finddirn
$findfile $findfile
$findfilen $findfilen
$findtok $findtok
$findtokcs $findtokcs
$fline $fline
$floor $floor
$fserve $fserve
$fulldate $fulldate
$fullname $fullname
$fullscreen $fullscreen
$getdir $getdir
$getdot $getdot
$gettok $gettok
$gmt $gmt
$hfind $hfind
$hget $hget
$highlight $highlight
$hnick $hnick
$host $host
$hotline $hotline
$hotlinepos $hotlinepos
$ial $ial
$ibl $ibl
$idle $idle
$iel $iel
$ifmatch $ifmatch
$ignore $ignore
$iif $iif
$iil $iil
$inellipse $inellipse
$ini $ini
$inpoly $inpoly
$inrect $inrect
$inroundrect $inroundrect
$insong $insong
$instok $instok
$int $int
$ip $ip
$isalias $isalias
$isbit $isbit
$isdde $isdde
$isdir $isdir
$isfile $isfile
$isid $isid
$islower $islower
$istok $istok
$istokcs $istokcs
$isupper $isupper
$lactivecid $lactivecid
$left $left
$len $len
$level $level
$lf $lf
$line $line
$lines $lines
$lock $lock
$locked $locked
$log $log
$logdir $logdir
$logstamp $logstamp
$logstampfmt $logstampfmt
$longfn $longfn
$longip $longip
$lower $lower
$maddress $maddress
$mask $mask
$matchtok $matchtok
$matchtokcs $matchtokcs
$md5 $md5
$me $me
$menubar $menubar
$mid $mid
$mircdir $mircdir
$mircexe $mircexe
$mircini $mircini
$mklogfn $mklogfn
$mklogfn $mklogfn
$mnick $mnick
$mode $mode
$modespl $modespl
$mouse $mouse
$msfile $msfile
$network $network
$nick( $nick_(nick)
$nick $nick_(remote)
$nofile $nofile
$nopath $nopath
$not $not
$notags $notags
$notify $notify
$null $null
$numtok $numtok
$online $online
$onpoly $onpoly
$opnick $opnick
$or $or
$ord $ord
$os $os
$pi $pi
$pi $pi
$pic $pic
$play $play
$port $port
$portable $portable
$portfree $portfree
$pos $pos
$prefix $prefix
$prop $prop
$protect $protect
$puttok $puttok
$qt $qt
$rand $rand
$rawmsg $rawmsg
$read $read
$readini $readini
$readn $readn
$regex $regex
$regml $regml
$regsub $regsub
$regsubex $regsubex
$remote $remote
$remove $remove
$remtok $remtok
$remtokcs $remtokcs
$replace $replace
$replacecs $replacecs
$replacex $replacex
$replacexcs $replacexcs
$reptok $reptok
$reptokcs $reptokcs
$result $result
$rgb $rgb
$right $right
$round $round
$scid $scid
$scon $scon
$scriptdir $scriptdir
$sdir $sdir
$server $server
$serverip $serverip
$sfile $sfile
$sha1 $sha1
$shortfn $shortfn
$show $show
$signal $signal
$sin $sin
$sline $sline
$snick $snick
$snicks $snicks
$snotify $snotify
$sock $sock
$sockname $sockname
$sorttok $sorttok
$sorttokcs $sorttokcs
$sqrt $sqrt
$ssl $ssl
$sslready $sslready
$status $status
$str $str
$strip $strip
$style $style
$submenu $submenu
$switchbar $switchbar
$tan $tan
$ticks $ticks
$time $time
$timestamp $timestamp
$timestampfmt $timestampfmt
$timezone $timezone
$tip $tip
$toolbar $toolbar
$treebar $treebar
$true $true
$trust $trust
$ulevel $ulevel
$ulist $ulist
$upper $upper
$uptime $uptime
$v1 $v1
$v2 $v1
$version $version
$vnick $vnick
$vol $vol
$width $width
$wildtok $wildtok
$wildtokcs $wildtokcs
$window( $window_(remote)
$window $window_(picwin)
$wrap $wrap
$xor $xor
$+ DollarPlus

Test2

2011-02-03T13:07:40Z

Vliedel:

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; 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-|$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]] }
}
}

$hget

2011-02-03T13:06:07Z

Vliedel:

As you can give $hget different parameters, they will be listed one by one:

*Returns name of a hash table if it exists, or returns the name of the Nth hash table.
$hget(name/N)[.size]

The size property returns the N size of table, as specified in [[Hmake|/hmake]].

*Returns the data associated with an item in the specified hash table.
$hget(name/N, item)[.unset]
The unset property returns the time remaining before an item is unset.

*Assigns the contents of an item to a &binvar.
$hget(name/N, item, &binvar)

*This allows you to reference the table as an index from 0 to N, in order to look up the Nth item in the table.
$hget(name/N, N).item

If N is zero, it returns the total number of items in the table.

You can also reference the Nth data value directly with $hget().data, but note, that this method is provided as a convenience, it is not an efficient way to use the hash table.

== Example ==

At first, we need a hashtable for all examples, so lets make one:
; have a nice alias called ''makehash'' for it
[[alias]] makehash {
; here we actually ''make'' the hashtable
[[hmake]] testhash 100
; now lets put data in it
[[hadd]] testhash Dana Dana@staff.quakenet.org
hadd testhash user1 user1@random.host
hadd testhash user2 user2@another.host
}

[[echo]] -a $hget(testhash) has the size: $hget(testhash).size
This example will echo ''makehash has the size: 100''.
echo -a $hget(testhash,user1)
This one will echo ''user1@random.host'' as it's the data connected to ''user1''.

The following, more complex example will loop through the entire table and echo everything:
; lets make a little alias called ''showhash''. At the end, it will look like ''/showhash <name>''
alias showhash {
; echo the name and a kind of "table header"
echo -a $1
echo -a item => data
[[var]] %i = 1
; lets loop through all items. $hget($1,0).item will return the total amount of items.
[[while]] (%i <= $hget($1,0).item) {
echo -a $hget($1,%i).item => $hget($1,%i).data
; increase looping-variable
inc %i
}
}
Using ''/showhash testhash'' will echo:
user1 => user1@random.host
user2 => user2@another.host
Dana => Dana@staff.quakenet.org

[[Category:Hash Table]]
[[Category:Identifiers]]

$hfind

2011-02-03T13:05:51Z

Vliedel:

Searches table for the Nth item name which matches text. Returns item name.
$hfind(name/N, text, N, M)[.data]

If you specify the .data property, it searches for a matching data value.

M is optional, and can be:
<table width="50%">
<tr><td width="10%">M</td><td>Explanation</td></tr>
<tr><td>n</td><td>normal text comparison (default if M isn't specified)</td></tr>
<tr><td>w</td><td>text is wildcard text</td></tr>
<tr><td>W</td><td>hash table item/data is wildcard text</td></tr>
<tr><td>r</td><td>text is regular expression</td></tr>
<tr><td>R</td><td>hash table item/data is regular expression</td></tr>
</table>

'''Note''' that if you specify N = 0, it will return the total amount of matching items (see the second example below).

== Example ==
At first, we need a hashtable for all examples, so lets make one:
; have a nice alias called ''makehash'' for it
[[alias]] makehash {
; here we actually ''make'' the hashtable
[[hmake]] testhash 100
; now lets put data in it
[[hadd]] testhash Dana Dana@staff.quakenet.org
hadd testhash user1 user1@random.host
hadd testhash user2 user2@another.host
}

The first example will just search for user1@random.host and returns the item (''user1''):
[[echo]] -a $hfind(testhash,Dana@staff.quakenet.org,1).data

The next example will loop through all data's containing *user* and return the item and data.

''user1 => user1@random.host''

''user2 => user2@another.host''
[[var]] %i = 1
; let's start the looping. $find(testhash,*user*,0,w).data returns the total amount of found items.
[[while]] (%i <= $hfind(testhash,*user*,0,w).data) {
; this echos it to the active window. $hget(testhash,$hfind(testhash,*user*,%i,w)) returns
; the data of the found item.
echo -a $hfind(testhash,*user*,%i,w) => [[$hget]](testhash,$hfind(testhash,*user*,%i,w))
; increase the looping-variable
[[inc]] %i
}

[[Category:Hash Table]]
[[Category:Identifiers]]

Test2

2011-02-03T12:56:32Z

Vliedel:

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; 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-Then-Else|if]] ([[$nick_(remote)|$nick]] == [[$me]]) && (![[|$timer]]([[DollarPlus|$+]]([[$cid]],.ial-update.update))) {
.![[timer]] [[DollarPlus|$+]] [[$cid]] [[DollarPlus|$+]] .ial-update.update 1 $$delay.who ial-update.update
}
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; LOAD EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
on *:load:{ !scon -at1 .!timer [[$!]][[DollarPlus|+]] [[$!]][[cid]] [[$!]][[DollarPlus|+]] .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 {
![[Local_Variables|var]] %c, %n
; IAL is set on
[[If-Then-Else|if]] ([[$ial]]) {
; hash table does not exist, set a var with the channels we need to 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
[[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
[[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
[[If-Then-Else|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-Then-Else|if]] (%c) || (%n) || ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]))) {
.![[timer]] [[DollarPlus|$+]] [[$cid]] [[DollarPlus|$+]] .ial-update.update 1 $$repeat.who ial-update.update
}
; return some info
[[If-Then-Else|if]] (%c) || (%n) { ![[return]] updating }
[[If-Then-Else|elseif]] ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]))) { ![[return]] already in progress }
[[If-Then-Else|else]] { ![[return]] nothing to update }
}
; ial is off return some info
[[If-Then-Else|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 {
![[Local_Variables|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-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
}
; 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 {
![[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
[[while]] (%x <= [[$numtok]](%c,32)) && (%t < [[$1-|$1]]) {
![[inc]] %t [[$gettok]]([[$gettok]](%c,%x,32),1,46)
; if %t is greater then $1, stop the loop
[[If-Then-Else|if]] (%t > [[$1-|$1]]) { ![[break]] }
; add it to a var
![[Local_Variables|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 {
![[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
[[while]] (%x <= [[$numtok]](%c,32)) && (%l < [[$1-|$2]]) {
![[inc]] %l [[$len]]([[$comchan]]([[$me]],[[$gettok]](%c,%x,32)))
; %l greater then $2, stop the loop
[[If-Then-Else|if]] (%l > [[$1-|$2]]) { ![[break]] }
; add it to the var
![[Local_Variables|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 {
![[Local_Variables|var]] %x = 1
; loop through the channels untill we found one where the IAL isnt updated
[[while]] ([[$chan_(window)|$chan(]][[$comchan]]([[$me]],%x)).ial != $false) && (%x <= [[$comchan]]([[$me]],0)) {
![[inc]] %x
}
; ial is not updated, set vars
[[If-Then-Else|if]] ([[$chan_(window)|$chan(]][[$comchan]]([[$me]],%x)).ial == $false) { ![[Local_Variables|var]] %y = 1, %t = 0, %l = 0, %w
; loop
[[while]] (%t <= [[$1-|$1]]) && (%l < [[$1-|$2]]) && (%y <= [[$nick_(nick)|$nick(]][[$comchan]]([[$me]],%x),0)) {
; ial for that nick isnt updated, increase %l
[[If-Then-Else|if]] (![[$ial]]([[$nick_(nick)|$nick(]][[$comchan]]([[$me]],%x),%y))) {
![[inc]] %l [[$len]]([[$nick_(nick)|$nick(]][[$comchan]]([[$me]],%x),%y))
; if greater then $2, stop the loop
[[If-Then-Else|if]] (%l > [[$1-|$2]]) { ![[break]] }
; add it to the var
![[Local_Variables|var]] %w = [[$addtok]](%w,[[$nick_(nick)|$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-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
[[while]] (%x) { ![[hadd]] -m [[DollarPlus|$+]](ial-update.,[[$cid]]) [[$gettok]]([[$1-|$1]],%x,44) 1 | ![[dec]] %x }
; add mask
![[hadd]] -m [[DollarPlus|$+]](ial-update.,[[$cid]]) -mask [[$1-|$1]]
}
; $2 is -remove, set a var
[[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
[[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
![[hdel]] [[DollarPlus|$+]](ial-update.,[[$cid]]) -mask
; check hash table, free hash table
[[If-Then-Else|if]] ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]),0).item == 0) && ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]))) { ![[hfree]] [[DollarPlus|$+]](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-Then-Else|if]] ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]),[[$1-|$2]])) || ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]),[[$1-|$6]])) {
; check setting, set a var
[[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
[[while]] (%x) { ![[Local_Variables|var]] %c = [[$comchan]]([[$1-|$6]],%x)
; check has table
[[If-Then-Else|if]] ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]),%c)) {
; * meaning oper isin $7, increase
[[If-Then-Else|if]] (* isin [[$1-|$7]]) { ![[hinc]] [[DollarPlus|$+]](ial-update.,[[$cid]]) [[DollarPlus|$+]](%c,[[$chr]](44),oper) }
; G meaning Gone isin $7, increase
[[If-Then-Else|if]] (G isincs [[$1-|$7]]) { ![[hinc]] [[DollarPlus|$+]](ial-update.,[[$cid]]) [[DollarPlus|$+]](%c,[[$chr]](44),away) }
; d meaning deaf isin $7, increase
[[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
[[If-Then-Else|if]] (x isincs [[$1-|$7]]) { ![[hinc]] [[DollarPlus|$+]](ial-update.,[[$cid]]) [[DollarPlus|$+]](%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-Then-Else|if]] ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]),-mask) == [[$1-|$2]]) {
; check setting, set a var
[[If-Then-Else|if]] ($show.who == 1) { ![[Local_Variables|var]] %x = [[$numtok]]([[$1-|$2]],44)
; loop, we are on the channel, set var
[[while]] (%x) { [[If-Then-Else|if]] ([[$me]] ison [[$gettok]]([[$1-|$2]],%x,44)) { ![[Local_Variables|var]] %c = [[$gettok]]([[$1-|$2]],%x,44)
; oper info
![[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_(nick)|$nick(]]%c,0) * 100),1) [[DollarPlus|$+]] % Oper
; away info
![[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_(nick)|$nick(]]%c,0) * 100),1) [[DollarPlus|$+]] % Away
; deaf info
![[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_(nick)|$nick(]]%c,0) * 100),1) [[DollarPlus|$+]] % deaf
; xhost info
![[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_(nick)|$nick(]]%c,0) * 100),1) [[DollarPlus|$+]] % x-host
; echo
![[echo]] -t [[$gettok]]([[$1-|$2]],%x,44) * IAL updated ( [[DollarPlus|$+]] %oper ---- %away ---- %deaf ---- %xhost [[DollarPlus|$+]] )
}
; remove from hash table
![[hdel]] [[DollarPlus|$+]](ial-update.,[[$cid]]) [[DollarPlus|$+]](%c,[[$chr]](44),oper) | ![[hdel]] [[DollarPlus|$+]](ial-update.,[[$cid]]) [[DollarPlus|$+]](%c,[[$chr]](44),away)
![[hdel]] [[DollarPlus|$+]](ial-update.,[[$cid]]) [[DollarPlus|$+]](%c,[[$chr]](44),deaf) | ![[hdel]] [[DollarPlus|$+]](ial-update.,[[$cid]]) [[DollarPlus|$+]](%c,[[$chr]](44),xhost)
![[dec]] %x
}
}
; remove the items from the hash table
ial-update.hash [[$1-|$2]] -remove
![[haltdef]]
}
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; DISCONNECT EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
on *:disconnect:{ [[If-Then-Else|if]] ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]))) { ![[hfree]] [[DollarPlus|$+]](ial-update.,[[$cid]]) } }

Test2

2011-02-03T12:55:07Z

Vliedel:

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; 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-Then-Else|if]] ([[$nick_(remote)|$nick]] == [[$me]]) && (![[|$timer]]([[DollarPlus|$+]]([[$cid]],.ial-update.update))) {
.![[timer]] [[DollarPlus|$+]] [[$cid]] [[DollarPlus|$+]] .ial-update.update 1 $$delay.who ial-update.update
}
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; LOAD EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
on *:load:{ !scon -at1 .!timer [[$!]][[DollarPlus|+]] [[$!]][[cid]] [[$!]][[DollarPlus|+]] .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 {
![[Local_Variables|var]] %c, %n
; IAL is set on
[[If-Then-Else|if]] ([[$ial]]) {
; hash table does not exist, set a var with the channels we need to 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
[[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
[[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
[[If-Then-Else|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-Then-Else|if]] (%c) || (%n) || ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]))) {
.![[timer]] [[DollarPlus|$+]] [[$cid]] [[DollarPlus|$+]] .ial-update.update 1 $$repeat.who ial-update.update
}
; return some info
[[If-Then-Else|if]] (%c) || (%n) { ![[return]] updating }
[[If-Then-Else|elseif]] ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]))) { ![[return]] already in progress }
[[If-Then-Else|else]] { ![[return]] nothing to update }
}
; ial is off return some info
[[If-Then-Else|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 {
![[Local_Variables|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-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
}
; 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 {
![[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
[[while]] (%x <= [[$numtok]](%c,32)) && (%t < [[$1|$1]]) {
![[inc]] %t [[$gettok]]([[$gettok]](%c,%x,32),1,46)
; if %t is greater then $1, stop the loop
[[If-Then-Else|if]] (%t > [[$1|$1]]) { ![[break]] }
; add it to a var
![[Local_Variables|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 {
![[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
[[while]] (%x <= [[$numtok]](%c,32)) && (%l < [[$1|$2]]) {
![[inc]] %l [[$len]]([[$comchan]]([[$me]],[[$gettok]](%c,%x,32)))
; %l greater then $2, stop the loop
[[If-Then-Else|if]] (%l > [[$1|$2]]) { ![[break]] }
; add it to the var
![[Local_Variables|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 {
![[Local_Variables|var]] %x = 1
; loop through the channels untill we found one where the IAL isnt updated
[[while]] ([[$chan_(window)|$chan(]][[$comchan]]([[$me]],%x)).ial != $false) && (%x <= [[$comchan]]([[$me]],0)) {
![[inc]] %x
}
; ial is not updated, set vars
[[If-Then-Else|if]] ([[$chan_(window)|$chan(]][[$comchan]]([[$me]],%x)).ial == $false) { ![[Local_Variables|var]] %y = 1, %t = 0, %l = 0, %w
; loop
[[while]] (%t <= [[$1|$1]]) && (%l < [[$1|$2]]) && (%y <= [[$nick_(nick)|$nick(]][[$comchan]]([[$me]],%x),0)) {
; ial for that nick isnt updated, increase %l
[[If-Then-Else|if]] (![[$ial]]([[$nick_(nick)|$nick(]][[$comchan]]([[$me]],%x),%y))) {
![[inc]] %l [[$len]]([[$nick_(nick)|$nick(]][[$comchan]]([[$me]],%x),%y))
; if greater then $2, stop the loop
[[If-Then-Else|if]] (%l > [[$1|$2]]) { ![[break]] }
; add it to the var
![[Local_Variables|var]] %w = [[$addtok]](%w,[[$nick_(nick)|$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-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
[[while]] (%x) { ![[hadd]] -m [[DollarPlus|$+]](ial-update.,[[$cid]]) [[$gettok]]([[$1|$1]],%x,44) 1 | ![[dec]] %x }
; add mask
![[hadd]] -m [[DollarPlus|$+]](ial-update.,[[$cid]]) -mask [[$1|$1]]
}
; $2 is -remove, set a var
[[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
[[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
![[hdel]] [[DollarPlus|$+]](ial-update.,[[$cid]]) -mask
; check hash table, free hash table
[[If-Then-Else|if]] ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]),0).item == 0) && ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]))) { ![[hfree]] [[DollarPlus|$+]](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-Then-Else|if]] ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]),[[$1|$2]])) || ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]),[[$1|$6]])) {
; check setting, set a var
[[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
[[while]] (%x) { ![[Local_Variables|var]] %c = [[$comchan]]([[$1|$6]],%x)
; check has table
[[If-Then-Else|if]] ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]),%c)) {
; * meaning oper isin $7, increase
[[If-Then-Else|if]] (* isin [[$1|$7]]) { ![[hinc]] [[DollarPlus|$+]](ial-update.,[[$cid]]) [[DollarPlus|$+]](%c,[[$chr]](44),oper) }
; G meaning Gone isin $7, increase
[[If-Then-Else|if]] (G isincs [[$1|$7]]) { ![[hinc]] [[DollarPlus|$+]](ial-update.,[[$cid]]) [[DollarPlus|$+]](%c,[[$chr]](44),away) }
; d meaning deaf isin $7, increase
[[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
[[If-Then-Else|if]] (x isincs [[$1|$7]]) { ![[hinc]] [[DollarPlus|$+]](ial-update.,[[$cid]]) [[DollarPlus|$+]](%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-Then-Else|if]] ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]),-mask) == [[$1|$2]]) {
; check setting, set a var
[[If-Then-Else|if]] ($show.who == 1) { ![[Local_Variables|var]] %x = [[$numtok]]([[$1|$2]],44)
; loop, we are on the channel, set var
[[while]] (%x) { [[If-Then-Else|if]] ([[$me]] ison [[$gettok]]([[$1|$2]],%x,44)) { ![[Local_Variables|var]] %c = [[$gettok]]([[$1|$2]],%x,44)
; oper info
![[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_(nick)|$nick(]]%c,0) * 100),1) [[DollarPlus|$+]] % Oper
; away info
![[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_(nick)|$nick(]]%c,0) * 100),1) [[DollarPlus|$+]] % Away
; deaf info
![[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_(nick)|$nick(]]%c,0) * 100),1) [[DollarPlus|$+]] % deaf
; xhost info
![[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_(nick)|$nick(]]%c,0) * 100),1) [[DollarPlus|$+]] % x-host
; echo
![[echo]] -t [[$gettok]]([[$1|$2]],%x,44) * IAL updated ( [[DollarPlus|$+]] %oper ---- %away ---- %deaf ---- %xhost [[DollarPlus|$+]] )
}
; remove from hash table
![[hdel]] [[DollarPlus|$+]](ial-update.,[[$cid]]) [[DollarPlus|$+]](%c,[[$chr]](44),oper) | ![[hdel]] [[DollarPlus|$+]](ial-update.,[[$cid]]) [[DollarPlus|$+]](%c,[[$chr]](44),away)
![[hdel]] [[DollarPlus|$+]](ial-update.,[[$cid]]) [[DollarPlus|$+]](%c,[[$chr]](44),deaf) | ![[hdel]] [[DollarPlus|$+]](ial-update.,[[$cid]]) [[DollarPlus|$+]](%c,[[$chr]](44),xhost)
![[dec]] %x
}
}
; remove the items from the hash table
ial-update.hash [[$1|$2]] -remove
![[haltdef]]
}
}
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; DISCONNECT EVENT ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
on *:disconnect:{ [[If-Then-Else|if]] ([[|$hget]]([[DollarPlus|$+]](ial-update.,[[$cid]]))) { ![[hfree]] [[DollarPlus|$+]](ial-update.,[[$cid]]) } }

$sock

2011-02-03T12:27:39Z

Vliedel: wow this page is still very ugly

'''$sock(name,N)''' 
This returns information about a socket connection that you created using the socket commands.

Properties: 
.name is the name you give to a connection to identify it 
.addr original named address if one was used. 
.sent and .rcvd return the number of bytes sent and rcvd over that connection so far 
.sq and .rq return the number of bytes queued in the send and receive buffers respectively 
.ls and .lr return the number of seconds since the connection last sent and last received info 
.mark is a user storage area max. 512 bytes (see [[sockmark|/sockmark]]) 
.type returns the socket type, TCP or UDP 
.saddr and .sport return the source address and port of the last received UDP packet 
.to returns the number of seconds the socket has been open 
.wserr returns the last winsock error number that occurred on a socket 
.wsmsg returns the last winsock error message match the error number 
.ssl returns $true for an SSL connection 
.pause returns $true if a socket has been paused

'''Note:''' You can use a wildcard name to quickly reference matching entries. The N parameter is optional, if it isn't specified it is assumed to be 1.

[[Category:Socket]]
[[Category:Identifiers]]

$sockname

2011-02-03T12:26:59Z

Vliedel:

$sockname is the name given to a connection to identify it. This identifier can be used in events to know which connection an event is related to.

[[Category:Socket]]
[[Category:Identifiers]]

$sline

2011-02-03T08:43:54Z

Vliedel:

Returns the selected line in a [[:Category:Custom Windows|window]] listbox.

$sline(@window, line)[.ln]

* @window is the custom window with a listbox to look in. The window MUST have a listbox.
* Line is the line number to retrieve. In other words, the Nth selected line.
* Returns: The Nth selected line in @Window
** If the .ln property is specified, it will return the line number in the window that the Nth selected line is on.
** If N=0, returns the total number of selected lines.

==Examples==
There are $sline(@mywindow,0) lines selected in @mywindow.

The 5th selected line is: $sline(@mywindow,5)

This is re-invinting the wheel to demonstrate .ln

The 5th selected line is: [[$line]](@mywindow,$sline(@window,5).ln)

==See Also==
[[window]] [[$window]] [[$line]] [[$fline]]

[[Category:Custom Windows]]
[[Category:Window Identifiers]]

$line

2011-02-03T08:43:45Z

Vliedel:

Line is used to get information on a line of text in an mIRC [[:Category:Custom Windows|window]]. Note this works for channel windows as well as [[:Category:Custom Windows|custom windows]].

$line(window, line[, T])[.state|.color]

* Window is the mIRC [[Custom Windows|window]] to check.
* Line is the line number to check. 0 will return the number of lines in the window.
* T is an optional flag to specify which location.
** 0 means the display area, 1 means the listbox.
* The .state property returns [[$true]] or [[$false]] based on whether or not the line is selected.
* The .color property returns the line's color.
* No property returns the string at this line, [[$null]], or the number of lines (if line = 0).

==Example==
[[If-Then-Else|if]] ($line(@mywindow,5,1).state) { [[echo]] -atg Line 5 is selected. }

[[If-Then-Else|if]] ($line(@window,5) == The end is near) { [[echo]] -atg Apparently the end is near. }

[[If-Then-Else|if]] ($line(@window,5).color == 1) { [[echo]] -atg Line 5 is in black. }

[[Category:Custom Windows]]
[[Category:Window Identifiers]]

$fline

2011-02-03T08:43:39Z

Vliedel:

Returns the number of the line in a [[Custom_Windows|custom window]] that matches the specified wildtext or regular expression.

$fline(@name,wildtext|regexp [,N][,T])

* The first parameter is the name of the window.
* The second parameter is the wildcard string to attempt to match a line against.
* N is the line number to start your search from. It is optional, and will default to 1 (the entire window).
* T is an optional flag that specifies the location of the search in the window.
** 1 indicates to reference the listbox.
** 2 indicates that a regular expression was specified.
** 3 indicates both (to reference the listbox, and use a regular expression)

[[Category:Custom Windows]]
[[Category:Window Identifiers]]

$tip

2011-02-03T08:42:20Z

Vliedel:

The $tip() identifer allows you to create scripted tips that are independent of normal tip events.
$tip(name,title,text,[delay,iconfn,iconpos,alias,wid])
; Returns Nth position of tip if it was successfully created, zero if not.

$tip(name/N)
; Returns properties for the specified tip.

== Parameters and properties ==
* name - name of the tip
* title - title
* text - text
* delay - from 3 to 60 seconds
* iconfn - icon filename
* iconpos - icon position in filename
* alias - alias to perform when tip is double-clicked
* wid - id of window to which tip belongs

[[Category:Tips]]
[[Category:Identifiers]]

$width

2011-02-03T08:41:10Z

Vliedel:

Returns width of text in pixels for the specified font.
$width(text,font,size,B,C)

If B is non-zero, the font is bold, if C is non-zero, control codes are processed. Both B and C are optional.

'''Note:''' If you use a negative number for the font size, it will match the size of fonts in the font dialog.

== Example ==

$width(Lorem ispum,Arial,12)
Returns 74.

== See Also ==

* [[$wrap]]
* [[font|/font]]

[[Category:Picture Windows]]
[[Category:Identifiers]]

$getdot

2011-02-03T08:40:46Z

Vliedel:

Returns the RGB color value of the dot at the specified position.
$getdot(@,x,y)

== Example ==

$getdot(@picwin,50,10)
Returns the RGB color value of the dot in @picwin at (50,10)

== See Also ==

* [[drawdot|/drawdot]] - Draws a dot on a picture window.
* [[$rgb]] - Returns an RGB color value.

[[Category:Picture Windows]]
[[Category:Identifiers]]

$abook

2011-02-02T23:19:58Z

Vliedel:

Returns informations about users, stored in [[MIRC|mIRC]]s internal [[Address book|address book]].

$abook(nick,N)

* If both ''nick'' and ''N'' is supplied mIRC will think nick is supplied in wildcarded form. Thus returning the Nth entry in the address book.
* If only ''N'' is used it will return the Nth entry. If ''N'' is 0 it will return the number of entries in the address book.
* If only a ''nick'' is used it will return info about that nick.

Properties:
* ''nick'' will return the nick associated with an entry.
* ''info'' will return the name field stored with a nick.
* ''email'' will return the email address associated with nick.
* ''website'' will return the website supplied with nick.
* ''picture'' will return the full path to the picture you have assigned the user.
* ''noteN'' will return the Nth note assigned to that users entry. N being a number.

== Examples ==
We have added [[Dana]] to our address book. And can thus use the following:

//[[Echo|echo]] -a $abook(Dana).info ;will return ''DDB v5 - #help.script servicebot by cmouse&k0sm0s''
//echo -a $abook(Dana).website ;will return ''http://script.quakenet.org/''
//echo -a $abook(Dana).note2 ;will return ''the second note saved with her''

//echo -a $abook(1).nick ;will return ''Dana'' if she is number 1 and/or the only one in the address book.
//echo -a $abook(Dan*,1).nick ;will return ''Dana'' since that is the first address book entry matching the given wildcard.

== See also ==
* [[Address Book]] for more information about the address book in general. 
* [[Abook]] for details on how to add people to the address book through commands.

[[Category:Userlist]]
[[Category:Remote Identifiers]]

$dlevel

2011-02-02T23:19:49Z

Vliedel:

Returns the default [[Userlist|user level]].
$dlevel

[[Category:Userlist]]
[[Category:Remote Identifiers]]

$level

2011-02-02T23:19:43Z

Vliedel:

Finds a matching address in the remote users list and returns its corresponding levels list.
$level(nick|address)

The levels will be returned as comma seperated list. If it is no general access level, a "=" will be infront of the level.

== Example ==
[[auser]] 1,2,3 Dana
[[echo]] -a $level(Dana)
This example would at first add Dana to your userlist and then echo its levels. The result would be "1,=2,=3".

== See Also ==
* [[Guser|/guser]] to add a user by his address.
* [[Ruser|/ruser]] to remove users from your user list.
* [[$ulevel]] to get the userlevel that was matched for the currectly triggered event.

[[Category:Userlist]]
[[Category:Remote Identifiers]]

$ulevel

2011-02-02T23:19:36Z

Vliedel:

Returns the user level that was matched for the currently triggered event.

== See Also ==
* [[Access Levels]]

[[Category:Userlist]]
[[Category:Remote Identifiers]]

$ulist

2011-02-02T23:19:29Z

Vliedel:

Returns the Nth address in the Users list that matches the specified address and level.

$ulist(nick!userid@address,L,N)

* Properties: info

You can specify a [[wildcard]] address or a * to match any address in the user list. If you don't specify a full address, it completes the address with wildcards. If you don't specify ''N'', the first matching address is returned.

If you specify ''L'', only matching addresses that contain the specified level are returned.

Using the 'info' property it will return the info-line for the matched userlist entry.

* Note: ''L'' and ''N'' are optional, but if you specify ''L'', you must specify ''N''.

== Example ==

The following example will loop through the userlist and print/echo each entry.

[[var]] %x = 1
[[While loops|while]] (%x < $ulist(*!*@*,0)) {
[[echo]] -a * %x [[DollarPlus|$+]] ) Mask: $ulist(*!*@*,%x) Level: [[$level]]($ulist(*!*@*,%x)) Info: [[$iif]]($ulist(*!*@*,%x).info,[[$v1]],none)
[[inc]] %x
}

== See Also ==
* [[Access Levels]] for more information on mIRCs internal userlist.

[[Category:Userlist]]
[[Category:Remote Identifiers]]

$ulevel

2011-02-02T23:19:07Z

Vliedel:

Returns the user level that was matched for the currently triggered event.

== See Also ==
* [[Access Levels]]

[[Category:Userlist]]
[[Category:Identifiers]]

$level

2011-02-02T23:18:59Z

Vliedel:

$dlevel

2011-02-02T23:18:54Z

Vliedel:

Returns the default [[Userlist|user level]].
$dlevel

[[Category:Userlist]]
[[Category:Identifiers]]

$abook

2011-02-02T23:18:47Z

Vliedel:

$regsubex

2011-02-02T23:17:14Z

Vliedel:

Performs a regular expression match, like [[$regex]], and then performs a substitution using subtext.
$regsubex([name], text, re, subtext)

Subtext is evaluated during substitution and can be an identifier.

Subtext can also contain special markers where
* \0 = number of matches
* \n = match number
* \t = match text
* \a = all match items
* \A = a non-spaced version of \a

Returns text result.

== Example ==

$regsubex(Example text.,/<[^>]+>/g,)
The above regular expression can be used to strip any HTML tags using $regsubex, returning the stripped text.

== See Also ==

* [[$regex]]
* [[$regsub]]

[[Category:Regular Expression]]
[[Category:Identifiers]]

$regsub

2011-02-02T23:17:06Z

Vliedel:

'''$regsub([name], text, re, subtext, %var)'''

Performs a regular expression match, like [[$regex|$regex()]], and then performs a substitution using subtext. 
Returns N, the number of substitutions made, and assigns the result to %var.

Example:
alias testing {
var %num_of_matches = $regsub(a dog was eating milk,/dog/g,cat,%new_content)
;%num_of_matches will have a value of 1, since 'dog' was mathced once
;%new_content will be 'a cat was eating milk'
}

[[Category:Regular_Expression]]
[[Category:Identifiers]]

$regml

2011-02-02T23:17:01Z

Vliedel:

'''$regml([name], N)''' 
'''Properties: pos'''

This can be used to reference the back referenced (items enclosed in parentheses) values returned by a call to [[$regex|$regex()]] or [[$regsub|$regsub()]].

If N = 0, returns total number of match strings. 
The pos property returns a strings position in the original match text.

[[Category:Regular_Expression]]
[[Category:Identifiers]]

$regex

2011-02-02T23:16:55Z

Vliedel:

'''$regex([name], text, re)'''

Returns N, the number of strings in text that matched the regular expression. 
You can assign a name to a $regex() call which you can use later in [[$regml|$regml()]] to reference a match list. 
If you don't specify a name, all identifiers use a default name which is overwritten with each call to $regex(). 
$regex() remembers the results for the last ten $regex() calls. Each time you do a match with $regex(), and you specify a name, that name's previous results are overwritten with the new results.

Example:
$regex(a cat walked by the dog,/cat|dog/g)
;'cat' and 'dog' are matched, returns 2
[[Category:Regular_Expression]]
[[Category:Identifiers]]

$activecid

2011-02-02T23:16:20Z

Vliedel:

Returns the connection id of the currently active window.
$activecid

== See Also ==
* [[$lactivecid]] to get the connection of the last active window.
* [[On_active|On active event]] to react on windows changes.

[[Category:Multi-server]]
[[Category:Identifiers]]