Scriptwiki - User contributions [en]

Cnick

2015-02-18T19:27:22Z

Saturn: add meaning of highlight methods

/cnick -raniovpylNmNsN [nick[!user@host]] [color] [modes] [levels]

This allows you to modify the items in the nick color list.

'''Optional arguments'''
[nick[!user@host]] nick/host of the user.
[color] the color you want to assign to the nick.
[modes] the list of modes required for that item to match, eg. @%+
[levels] makes mIRC search your [[:Category:Userlist|User List]] for a matching level and address.

'''Switches'''
-r removes the specified nick or address from the list.
-a sets the Any Mode option.
-n sets the No Mode option.
-iovpy set the ignore, op, voice, protect, and notify list options respectively.
-lN sets the idle time.
-mN sets the highlight method, 0, 1, or 2 (corresponding to Message&Listbox, Message, and Listbox, respectively).
-sN sorts the item into the Nth position in the list.

'''Note:'''
* You can use /cnick -r nick/N to remove first item that matches nick in the nick color list or the Nth item in the nick color list.
* To add or refer to an item as Any nick you can use the * character as the nick.
* [[cline|/cline]] over-rides the nick color list. You can use /cline -r to reset a nick to default color to make the nick color list apply to a nick.

== See Also ==
* [[$cnick]]
* [[Address book]]

[[Category:Commands]]

How do I reop or unban myself

2011-01-01T14:16:34Z

Saturn: typo, thanks FIQ

This tutorial will help you create a script that gives you some basic protection. Whenever someone deops you in your channel, it will automatically ask [[Q]] to reop you again. Also, when someone bans you, it will attempt to unban you again. Difficulty: easy

First we'll look at how [[mIRC]] scripting actually handles these things. Whenever something happens (a message, a mode change, a kick and so on), your script can react to this. What you need are the so called [[:Category:remote|remote]] [[:Category:Events|events]]. You can read more about them by typing /help remote in a mIRC window. I suggest you do that right now.

As you can see, the helpfile recommends you read through documents on [[:Category:Commands|Commands]], [[:Category:Aliases|Aliases]], [[:Category:Variables|Variables]] and [[:Category:Identifiers|Identifiers]]. Although it is always a good idea to do so, you might not fully understand what they do and how they work, so understanding all this is not required for this tutorial.

Besides this, you'll see two other things in the help file. One is a list with events, the other is a note at the end: Note: You should never load or use a script that you don't understand. Whatever you do, keep this in mind! Lots of users have their Q accounts compromised and other data lost, just because they run a false script.

Back to our problem. We want to get our ops back when someone removes it, so the event we need is the DeOp event. Click on it in the list. The [[On_op|on OP]] and [[On_deop|on DEOP]] events trigger when a user on a channel is opped or deopped. Sound like it's exactly what we need. Have a look at the format and the example below it:

Format: on <level>:OP:<#[,#]>:<commands>
Example: on 1:OP:#mirc,#irchelp:/[[msg]] [[$nick]] Please don't abuse your Op status

(on OP and on DEOP events work in a similar way.)

The ''1'' in the example is a [[Access Levels|userlevel]]. Userlevel 1 means the event always triggers, no matter what level the deop'ing user has, as mIRC per default assigns all users with level 1. The ''#mirc,#irchelp'' are obvioulsy channels the event should work for. Finally, the ''/msg $nick Please don't...'' part is the command that should be executed. ''$nick'' is an identifier. It returns something. If fishbot would have done the op, then mIRC would read the line as /msg fishbot Please don't... In words:

If someone with level 1 or higher (everyone) ops someone in #mirc or #irchelp, message him with Please don't abuse your Op status.

To use such an event, you'll need to paste it in [[:Category:Remote|Remote]]. Go to Tools -> Script editor or hit Alt + R. Should the field not be empty, then go to File and select New. If you'd want to use this event, you'd paste it in the large text field and press OK. For now, just press OK without pasting.

Let's say your channel is #mychannel. As we want this event to work for all userlevels too, we can make the biggest part of the event: on 1:DEOP:#mychannel:/command. The event can trigger more commands too. We're gonna change the format for that a bit:
on 1:DEOP:#mychannel:{
command1
command2
}

You might have seen the { } format before. Inside those, we can list as many commands as we want. Let's say your channel has [[Q]]. One of the commands we need would be: ''msg Q op #mychan''. Instead of #mychan, we can use another identifier. [[$chan]] returns the channel all this happens on, so let's change the command to ''msg Q op $chan''. This way you can use the same command for more than 1 channel.

Now we have another problem. If we'd use on 1:DEOP:#mychan:{ msg Q op $chan }, it would send the message if someone else gets deopped too. That's why we're gonna limit it using an [[If-Then-Else|if-statement]]. The if-statement basically checks something. If what it checks is true, it executes some commands. If not, it either does nothing or goes to an else part. For now we won't use else parts.

What we wanted to check was if it was you who got deopped. As the help on the [[On_op|op]]/[[On_deop|deop]] event says, [[$opnick]] returns the person/nick who get's opped/deopped in those events. We'll need to use another identifier: $me. $me simply returns your own nickname. The if-statement we need would become ''if ($opnick == $me) { commands }''. The == is an operator meaning 'equal to' and that's exactly what we want: "if (the person who gets deopped is equal to myself)"

Now, let's just put the if statement we just made inside the event:

on 1:DEOP:#mychannel:{
if ($opnick == $me) {
msg Q op $chan
}
}

This will do what we need. If you get deopped on your channel, it will ask Q to reop you. Have a look at the spaces in front of some of the lines. mIRC automatically adds them when you click OK or the { } button in the remote dialog. The { } button is really useful, because it lets mIRC check if you have placed the { and } brackets correctly. When you'll write bigger scripts, you'll start using it a lot.

We'll now create another event. We want it to unban you whenever you get banned on your channel. Let's start with having a look at what actually happens. When someone bans, he sets a banmask, for example *!milk@*.cows.net. This mask contains wildcards, which means it bans dynamically. A wildcard, *, can be replaced by anything: bill!milk@white.cows.net will for example be banned.

With help from the helpfile, we can easily create the following event:

[[On_ban|on @1:BAN]]:#mychannel:{
if ([[$bnick]] == $me) {
mode $chan -b [[$banmask]]
}
}

Click the parts above you don't understand to see more information on them.

This event will work in some cases, but unfortunately by far not in all. ''$bnick'' only works when a nick is specified inside the banmask, like: ''nick!*@*.*''. There is another possibility though.

If we want your full address, we can use [[$address]]($me,5) or [[$ial]]([[$me]]). (Again, click the identifiers mentioned for more detailed information on what they can do.)

We only used the == operator in if-statements until now. Now have a look at the [[If-Then-Else#The_Operators|iswm]] operator. It literally means is wildcard match. ''if (a*c iswm abc)'' would be true, ''if (ac* iswm abc)'' wouldn't.

Now, we can use this to check if the banmask matches your address; to check if 'you are banned':

on @1:BAN:#mychannel:{
if ($banmask iswm $ial($me)) {
mode $chan -b $banmask
}
}

That will do the trick.

When you fully understand how these events work, you should also be able to create events that do these things:

- [[Kick]] someone who deops your friend
- Only allow people with [[Access Levels|level]] 20 or higher to [[ban]]

[[Category:Tutorials]]
{{Author|Voronoi}}

Nick

2010-02-21T21:17:49Z

Saturn: fix nick match regex

Changes your nickname.

/nick new-nick

== Note ==
*Valid nickname characters are as follows: 0-9a-z\[]^_`{|}-
*A nickname must also '''not''' begin with a numeric or a hyphen (-).
*Some ircd reserve single character nicknames for service bots, QuakeNet '''is''' an example of this.
''Here is an example to check if %nick is a valid nickname or not:''
[[var]] %nick = /V/alid
var %regex = /^([][A-Za-z_\\^`{|}][][\w\\^`{|}-]*)/
[[If-Then-Else|if]] ([[$regex]](%nick,%regex)) {
[[echo]] -ag [[$regml]](1) is a valid nickname!
}
[[If-then-else|else]] { echo -ag %nick is not a valid nickname! }
'''Note:''' The above example, if you feed it with ''\Valid!nvalid'', it would return it as a valid nickname, although the only valid part of the nick is ''\Valid''. If you type /nick \Valid!nvalid the ircd would trim the nick to \Valid, this is why in the echo of a valid nickname we use $regml(1) instead of %nick, this is a back reference to the valid nickname captured.

If you also want to check that the nickname is atleast two characters long you can replace the * with a + as it will make sure that the second exists:
/^([][A-Za-z_\\^`{|}][][\w\\^`{|}-]+)/

The example below will only match if the whole nickname is valid, so it won't truncate the nickname:
/^([][A-Za-z_\\^`{|}][][\w\\^`{|}-]*)$/
== See Also ==
* {{Relatedraws|nick}}
* [[On nick|On nick event]]

[[Category:Basic IRC commands]]

How to query a CS Server

2009-04-16T18:18:05Z

Saturn: update to protocol 48, thanks to NaNg

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.

; HL server query snippet by Saturn
;
; 16-04-2009: update to protocol version 48 by NaNg
;
; usage:
; /hlinfo <ip> <port>
; /hlplay <ip> <port>

; the alias that opens a new socket if you want to get general information about a running CS-server
[[alias]] hlinfo {
; using a dynamic socket name so we can use multiple instances at once
[[var]] %sock = $+(hlinfo-,[[$ticks]])
; construct the query to send to the server
[[bset]] -t &t 1 [[$str]]([[$chr]](255),4) [[DollarPlus|$+]] TSource Engine Query
[[bset]] &t 25 0
; actually open the socket, and send the query
[[sockudp]] -k %sock [[$1-|$1]]-2 &t
; closing the socket after 60seconds if there is no response (else it will be closed by another event (see below))
.[[timer]] $+ %sock 1 60 [[sockclose]] %sock
}

; this event will get all data sent back from the server
[[on_udpread|on *:UDPREAD]]:hlinfo-*:{
; save it in a binary variable
[[sockread]] -f &reply

; set some local variables that we will use below
var %offset, %name, %map, %game, %num, %max, %ip, %dir

; following the protocol, this "m" shows us that we queried a Half-Life 1 server
if ($chr([[$bvar]](&reply,5)) == m) {
; Half-Life 1 info reply

%offset = 6

; save the ip
%ip = $bvar(&reply,%offset,128).text
[[inc]] %offset [[$calc]]([[$len]](%ip) + 1)

; the same
%name = $bvar(&reply,%offset,128).text
inc %offset $calc($len(%name) + 1)

; the current map
%map = $bvar(&reply,%offset,128).text
inc %offset $calc($len(%map) + 1)

; the game directory
%dir = $bvar(&reply,%offset,128).text
inc %offset $calc($len(%dir) + 1)

; the name of the game
%game = $bvar(&reply,%offset,128).text
inc %offset $calc($len(%game) + 1)

; current and maximum players
%num = $bvar(&reply,%offset)
%max = $bvar(&reply,$calc(%offset + 1))
}

; else we get data for a CS:Source game
else {
; Source info reply
; we do the same as above
%offset = 7

%name = $bvar(&reply,%offset,128).text
inc %offset $calc($len(%name) + 1)

%map = $bvar(&reply,%offset,128).text
inc %offset $calc($len(%map) + 1)

%dir = $bvar(&reply,%offset,128).text
inc %offset $calc($len(%dir) + 1)

%game = $bvar(&reply,%offset,128).text
inc %offset $calc($len(%game) + 1)

%num = $bvar(&reply,$calc(%offset + 2))
%max = $bvar(&reply,$calc(%offset + 3))
}

; now we echo all stored details to the active window
[[echo]] -a Info for [[$sock]]([[$sockname]]).saddr $+ : $+ $sock($sockname).sport
echo -a Name: %name
echo -a Map: %map
echo -a Game: %game
echo -a Players: %num $+ / $+ %max

; and turn off the timer closing the socket
.timer $+ $sockname off
; as we can close it now manually
sockclose $sockname
}

; this is the alias that will be called from hlplay to open the socket
alias hlchal {
; $1 = ip, $2 = port, $3- = what to call when received
; use dynamic socket name as above
var %sock = $+(hlchal-,$ticks)
; open the socket, and ask for a player challenge number
sockudp -k %sock $1-2 $str($chr(255),4) $+ U $+ $str($chr(255),4)
; mark it with the ip and port (and the query we want to call when we've received something from the server)
[[sockmark]] %sock $3- $1-2
; and make a new timer to close it after 60 seconds
.timer $+ %sock 1 60 sockclose %sock
}

; read everything that comes back from the hlchal-* query
on *:UDPREAD:hlchal-*:{
; and save it in the binary variable called &reply
sockread -f &reply
; actually call the alias saved in the sockmark (hlplay_query)
$sock($sockname).mark $bvar(&reply,6,4)
; and turn the timer off because we can close it manually
.timer $+ $sockname off
sockclose $sockname
}

; the alias we can call to make everything easier
; it will call other aliases to open sockets etc.
alias hlplay {
hlchal $1-2 hlplay_query
}

; the alias that opens the _real_ socket to receive data (everything before was just to challenge the server (read the website mentioned above))
alias hlplay_query {
; set a binary variable
bset &query 1 255 255 255 255 85 $3-
; use dynamic socket names again
var %sock = $+(hlplay-,$ticks)
; open the socket
sockudp -k %sock $1-2 &query
; and turn on the timer closing the socket after 60seconds
.timer $+ %sock 1 60 sockclose %sock
}

; this event will receive all data from the server as response to our query
on *:UDPREAD:hlplay-*:{
; we save it in &reply
sockread -f &reply

; set some local variables we will use later
var %i = 1, %num = $bvar(&reply,6), %offset = 7
var %count = 0, %name, %kills

; and echo the number of players
echo -a Players on $sock($sockname).saddr $+ : $+ $sock($sockname).sport

; now we can loop through all player and save some details about them
[[while]] (%i [[If-Then-Else#<=|<=]] %num) {
inc %offset

; the name
%name = $bvar(&reply,%offset,128).text
inc %offset $calc($len(%name) + 1)

; the kills
%kills = $bvar(&reply,%offset).long
[[If-Then-Else|if]] ([[$isbit]](%kills,32)) [[dec]] %kills $calc(2^32)
inc %offset 8

; and if there was a player
if (%name [[If-Then-Else#!=|!=]] [[$null]]) {
; increase the variable that shows us the number of the player
inc %count
; and echo it to the active window with the kills saved above
echo -a %count $+ . %name - %kills
}

; increase %i so we go on with the next player
inc %i
}

; if there are no players online, echo it aswell
if (%count [[If-Then-Else#==|==]] 0) echo -a No players found!

; turn off the timer
.timer $+ $sockname off
; and close the socket manually
sockclose $sockname
}

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

User:Saturn

2009-04-03T13:54:05Z

Saturn:

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

<table border="0">
<tr>
<td>[[Image:Saturn.png]]</td>
<td>
<table border="0">
<tr><td><b>Name</b></td><td>David van Moolenbroek</td></tr>
<tr><td><b>Age</b></td><td>(unspecified)</td></tr>
<tr valign="top" height="40"><td><b>Country</b></td><td>The Netherlands</td></tr>

<tr><td><b>Words of wisdom</b></td><td>The eyes of truth are always watching you.</td></tr>
</table>
</td>
</tr>
</table>
[[Category:Members]]

Limits

2008-08-27T18:42:51Z

Saturn: update for channel keys limit

<font color=#FF0000>'''Warning: These values may be outdated for mIRC v6.32. Updated and confirmed sections are marked with </font><font color=#00AA00>(Updated)'''</font>

This page explains various limits imposed by mIRC, however this may not be a complete list. The length is measured in bytes (equivalent to ASCII characters, including spaces.)

You can find the original limits page [http://www.xise.nl/mirc/wiki/doku.php?id=limits here.]

= mIRC =
<table border=2 rules=all cellpadding=4 style=text-align:center><tr>
<td>'''Name'''</td><td>'''Length'''</td><td>'''When exceeded'''</td><td>'''Description'''</td></tr><tr>
<td colspan=0>'''Global limits <font color=#00AA00>(Updated)</font>'''</td></tr><tr>
<td>'''Line Length Limit'''<br>(''LLL'')</td><td>4150</td><td>Truncated or error<td style=text-align:left>To be precise: 4150 for evaluation results, 4151 for command lines (excluding command prefixes.)</td></tr><tr>
<td>'''Variables'''<br>(local or global)</td><td>4150</td><td>Unset</td><td style=text-align:left>This limit includes the variable's name. Example: using "%a" as a name uses 3 bytes (2 for the name and 1 for a space.)<br>This means that for every extra character in the variable name, the maximum length of the value is reduced.<br>'''Note:''' the /set command further reduces the length limit to 9144 due to the 4 characters used by "set ". (LLL)</td></tr><tr>
<td colspan=0>'''IRC server specific'''</td></tr><tr>
<td>'''Incoming lines'''</td><td>601</td><td>Truncated</td><td style=text-align:left>Excludes CR/LF.</td></tr><tr>
<td>'''Outgoing lines'''</td><td>LLL</td><td>Truncated</td><td style=text-align:left><font color=#00AA00>'''(Updated)'''</font></td></tr><tr>
<td>'''Joined channel names'''</td><td>255</td><td>Parted immediately</td><td style=text-align:left><font color=#00AA00>'''(Updated)'''</font> Includes channel prefix.</td></tr><tr>
<td>'''Channel keys'''</td><td>256</td><td>Truncated</td><td style=text-align:left><font color=#00AA00>'''(Updated)'''</font></td></tr><tr>
<td>'''Addresses'''</td><td>90</td><td>Truncated</td><td style=text-align:left>The part of the full address after the "!"; only with JOIN/QUIT messages, addresses from WHO replies are not truncated.</td></tr><tr>
<td>'''Nicknames'''</td><td>50</td><td>Truncated</td><td style=text-align:left></td></tr><tr>
<td>'''Server passwords'''</td><td>50</td><td>Truncated</td><td style=text-align:left>As associated with server entries</td></tr><tr>
<td colspan=0>'''CTCPs'''</td></tr><tr>
<td>'''Incoming PING argument'''</td><td>24</td><td>No reply sent</td><td style=text-align:left>First character must be a digit; leading spaces ignored.</td></tr><tr>
<td colspan=0>'''Sockets'''</td></tr><tr>
<td>'''Socket name'''</td><td>255</td><td>Error</td><td style=text-align:left><font color=#00AA00>'''(Updated)'''</font></td></tr><tr>
<td>'''Send buffer'''</td><td>16384</td><td>Error</td><td style=text-align:left>mIRC's own buffers, not WinSock's.</td></tr><tr>
<td>'''Receive buffer'''</td><td>4096</td><td>Receipt stalls</td><td style=text-align:left>mIRC's own buffers, not WinSock's.</td></tr><tr>
<td>'''Socket mark'''</td><td>LLL</td><td></td><td style=text-align:left><font color=#00AA00>'''(Updated)'''</font> Not 512 as the helpfile says.</td></tr><tr>
<td colspan=0>'''Hashtables <font color=#00AA00>(Updated)</font>'''</td></tr><tr>
<td>'''Hashtable name'''</td><td>256</td><td>Truncated</td><td style=text-align:left></td></tr><tr>
<td>'''Hashtable size'''</td><td>10000</td><td>Error</td><td style=text-align:left>In number of buckets</td></tr><tr>
<td colspan=0>'''GUI <font color=#00AA00>(Updated)</font>'''</td></tr><tr>
<td>'''Editbox'''</td><td>1024</td><td>Sent</td><td style=text-align:left>Editbox is cleared afterwards, similar to pressing Enter.</td></tr><tr>
<td colspan=0>'''Dialogs <font color=#00AA00>(Updated)</font>'''</td></tr><tr>
<td>'''Dialog name'''</td><td>256</td><td>Truncated</td><td style=text-align:left></td></tr><tr>
<td>'''Input dialog text field'''</td><td>1023</td><td>Truncated</td><td style=text-align:left></td></tr><tr>
<td colspan=0>'''Files <font color=#00AA00>(Updated)</font>'''</td></tr><tr>
<td>'''Line of text'''</td><td>4149</td><td>Split</td><td style=text-align:left>Excluding CR/LF. Applies to all file-related commands/identifiers.</td>
</tr></table>

Clear-Chanlev Script for QuakeNet

2008-04-12T12:15:57Z

Saturn: fix for "No channel specified" error

; ClearChanlev script by doomie
; #help.script @ QuakeNet
;
;
; You can use this script by typing:
;
; /clearchanlev [-c|-r] #channel
;
; Note, that you must be authed and owner of #channel.
;
; Flags:
; * -r ... Resets the script, i.e. cleans everything up. One usually doesn't need that flag, however, if something didn't work,
; one can use it.
; * -c ... If you use this flag, the script will remove you from the channel aswell. This means, that Q will leave the channel
; completly. Note that you can _NOT_ reverse it!
;
;
; Example output:
;
; ClearChanlev: -----------------------------
; ClearChanlev: Now beginning to remove all chanlevs from channel #channel except yours!
; ClearChanlev: Receiving own auth now!
; ClearChanlev: ...done.
; ClearChanlev: Saving chanlev now...
; ClearChanlev: ...done.
; ClearChanlev: There are 2 lines to send. This will take approximatly 4 seconds. Removing...
; ClearChanlev: ...done.
; ClearChanlev: Cleaned up!
; ClearChanlev: -----------------------------
;

; Returns the milliseconds between every message sent to Q
; If you excess flood, you should increase this value to 4000 or even 5000.
[[alias]] -l ClearChanlev.Delay { [[return]] 3000 }

; $1 = #channel
;
; flags:
; -c --complete = deletes the complete chanlev, inclusive owner. This will
; result in Q parting.
; -r --reset = resets the scripts in case something didn't work the last time.
alias ClearChanlev {
[[echo]] -s ClearChanlev: -----------------------------
[[var]] %i = 1, %c, %ClearChanlev.Complete = 0, %r, %ClearChanlev.Force = 0, %ClearChanlev.Channel
[[While loops|while]] (%i [[If#.3C.3D|<=]] [[$0]]) {
%c = $ [[Evaluation_brackets|[]] [[DollarPlus|$+]] [[Evaluation_brackets|[]] %i [[Evaluation_brackets|] ]]]
[[if]] (%c [[If#.3D.3D|==]] -c) [[If#Combining_comparisons|||]] (%c == --complete) {
%ClearChanlev.Complete = 1
}
elseif (%c == -r) || (%c == --reset) {
%ClearChanlev.Force = 1
}
elseif ([[$left]](%c, 1) == [[$chr]](35)) {
%ClearChanlev.Channel = %c
}
[[inc]] %i
}
if (%ClearChanlev.Global) {
if (%ClearChanlev.Force == 0) {
echo -s ClearChanlev: ClearChanlev is currently running. If this is not the case, please use the -r flag (i.e. /clearchanlev -r #channel)
echo -s ClearChanlev: -----------------------------
return
}
else {
[[unset]] %ClearChanlev.Global
echo -s ClearChanlev: ClearChanlev reseted.
}
}
if (!%ClearChanlev.Channel) {
echo -s ClearChanlev: No channel specified.
return
}
%r = [[$rand]](1,1000)
[[set]] %ClearChanlev.Global %ClearChanlev.Channel %ClearChanlev.Complete %r
echo -s ClearChanlev: Now beginning to remove all chanlevs from channel %ClearChanlev.Channel [[$iif]](%ClearChanlev.Complete, inclusive, except) yours!
echo -s ClearChanlev: Receiving own auth now!
.[[timer]]ClearChanlevCleanUp 1 60 ClearChanlev.CleanUp
.[[who]] [[$me]] n%nat, $+ %r
}

[[:Category:Raws|raw]] [[Raw_354|354]]:*: {
if ([[$1-|$2]] == [[$gettok]](%ClearChanlev.Global, 3, 32)) && ($3 == $me) {
haltdef
set %ClearChanlev.Global %ClearChanlev.Global $4
}
}

raw [[Raw_315|315]]:*: {
if (%ClearChanlev.Global) && ($2 == $me) {
[[haltdef]]
if ($gettok(%ClearChanlev.Global, 4, 32) == 0) {
echo -s ClearChanlev: You are NOT authed.
ClearChanlev.CleanUp
}
else {
echo -s ClearChanlev: ...done.
set %ClearChanlev.Global %ClearChanlev.Global 0
.[[msg]] Q chanlev $gettok(%ClearChanlev.Global, 1, 32)
}
}
}

alias -l ClearChanlev.GotMessages {
if (![[$exists]](ClearChanlev $+ $gettok(%ClearChanlev.Global, 3, 32) $+ .txt)) {
echo -s ClearChanlev: File does not exist!
ClearChanlev.CleanUp
return
}
if ([[$lines]](ClearChanlev $+ $gettok(%ClearChanlev.Global, 3, 32) $+ .txt) == 0) {
echo -s ClearChanlev: No chanlev to remove!
ClearChanlev.CleanUp
return
}
if ($gettok(%ClearChanlev.Global, 5, 32) == 0) {
echo -s ClearChanlev: You are NOT owner of this channel. Aborting!
ClearChanlev.CleanUp
return
}
echo -s ClearChanlev: There are $lines(ClearChanlev $+ $gettok(%ClearChanlev.Global, 3, 32) $+ .txt) lines to send. This will take [[$&]]
approximatly $calc($lines(ClearChanlev $+ $gettok(%ClearChanlev.Global, 3, 32) $+ .txt) * $ClearChanlev.Delay / 1000) seconds. Removing...
.[[play]] Q ClearChanlev $+ $gettok(%ClearChanlev.Global, 3, 32) $+ .txt $ClearChanlev.Delay
}

alias -l ClearChanlev.CleanUp {
.[[remove]] ClearChanlev $+ $gettok(%ClearChanlev.Global, 3, 32) $+ .txt
unset %ClearChanlev.*
.timerClearChanlevCleanUp off
echo -s ClearChanlev: Cleaned up!
echo -s ClearChanlev: -----------------------------
}

; $1- = message from Q
alias -l ClearChanlev.Interpret {
if (%ClearChanlev.Global) {
if (Username*Flags*Last join*Last changed iswm $1-) {
echo -s ClearChanlev: Saving chanlev now...
set %ClearChanlev.Global %ClearChanlev.Global 1
}
elseif (You do not have sufficient access on* iswm $1-) {
echo -s ClearChanlev: You do not have sufficied access on the specified channel!
ClearChanlev.CleanUp
}
elseif (End of list. == $1-) {
echo -s ClearChanlev: ...done.
set %ClearChanlev.Global [[$puttok]](%ClearChanlev.Global, 0, 6, 32)
if ([[$numtok]](%ClearChanLev.Users,32)) {
[[write]] ClearChanlev $+ $gettok(%ClearChanlev.Global, 3, 32) $+ .txt REMOVEUSER $gettok(%ClearChanlev.Global, 1, 32) %ClearChanLev.Users
unset %ClearChanlev.Users
}
ClearChanlev.GotMessages
}
elseif (Channel * is unknown or suspended. iswm $1-) {
echo -s ClearChanlev: Channel is not known or suspended. Aborting.
ClearChanlev.CleanUp
}
elseif ($gettok(%ClearChanlev.Global, 6, 32) == 1) {
if ($1 == $gettok(%ClearChanlev.Global, 4, 32)) {
if (n !isin $2) {
set %ClearChanlev.Global $puttok(%ClearChanlev.Global, 0, 5, 32)
return
}
else {
set %ClearChanlev.Global $puttok(%ClearChanlev.Global, 1, 5, 32)
}

if ($gettok(%ClearChanlev.Global, 2, 32) == 0) {
return
}
else {
write ClearChanlev $+ $gettok(%ClearChanlev.Global, 3, 32) $+ .txt CHANLEV $gettok(%ClearChanlev.Global, 1, 32) $chr(35) $+ $1 [[$replace]]($2,+,-)
return
}
}
else {
if (n isin $2) {
write ClearChanlev $+ $gettok(%ClearChanlev.Global, 3, 32) $+ .txt CHANLEV $gettok(%ClearChanlev.Global, 1, 32) $chr(35) $+ $1 $replace($2,+,-)
}
else {
set %ClearChanlev.Users $addtok(%ClearChanLev.users,$chr(35) $+ $1,32)
if ($numtok(%ClearChanlev.Users,32) == 18) {
write ClearChanlev $+ $gettok(%ClearChanlev.Global, 3, 32) $+ .txt REMOVEUSER $gettok(%ClearChanlev.Global, 1, 32) %ClearChanlev.Users
unset %ClearChanlev.Users
}
}
}
}
}
}

on ^*:[[On_notice|Notice]]:*:?: {
if ([[$nick]] == Q) && (%ClearChanlev.Global) {
haltdef
ClearChanlev.Interpret $1-
}
}

on ^*:[[On_text|Text]]:*:?: {
if ($nick == Q) && (%ClearChanlev.Global) {
haltdef
ClearChanlev.Interpret $1-
}
}

on *:[[On_playend|PLAYEND]]:{
if ([[$nopath]]([[$filename]]) == ClearChanlev $+ $gettok(%ClearChanlev.Global, 3, 32) $+ .txt) {
echo -s ClearChanlev: ...done.
ClearChanlev.Cleanup
}
}
[[Category:Script Archive]]
{{Author|Doomie}}

How to make a VIP script

2007-06-12T16:51:15Z

Saturn: grammar

How to check if a user is opped on some channel where you/your bot isn't.
We'll be using vipchannels.txt to store the VIP channels we want to check, each channel on their own line, ie:
#myvipchannel
#somechannel
#help.script

On to the script:

on !*:join:#YOURCHAN:{
; We'll set a temporary global variable to indicate that we're checking the VIP, so we can halt the default /whois text from showing up
; Then we'll do whois on the nick. Note the "!" in the join event: it prevents the script from triggering, if it is you who joined
set %vipcheck 1
whois $nick
}

raw 319:*:{
; Channels list
; In this raw we loop through the txt-file vipchannels.txt and see if the user is opped on any of these channels
; This will only be done when the %vipcheck is set
if (%vipcheck) {
var %x = 1
while ($read(vipchannels.txt,%x)) {
; put the channel name into a variable %c
var %c = $v1

; see if $+(@,%c) (equals: @ $+ #somevipchannel) is found from the users channels
if ($istok($3-,$+(@,%c),32)) {

; @#somevipchannel was found, so the user is opped on this channel, we tell the user that he's a vip, and set mode +o for him on another chan (note that $2 is the users nick here)
msg $2 you are opped on %c $+ , and that makes you a VIP.
mode #YOURCHAN +o $2
break
}
inc %x
}

; haltdef so that you don't see the channels everytime someone joins
haltdef
}
}

raw 318:*:{
; end of /whois
; here we just unset the temporary variable %vipcheck, so we can use normal /whois again
if (%vipcheck) { unset %vipcheck | haltdef }
}

;;; Halting other /whois information from showing up
raw 301:*:{
; away
if (%vipcheck) { haltdef }
}
raw 311:*:{
; user's ident, host and realname
if (%vipcheck) { haltdef }
}
raw 312:*:{
; server information
if (%vipcheck) { haltdef }
}
raw 313:*:{
; if the user is IRCop
if (%vipcheck) { haltdef }
}
raw 317:*:{
; signon and idle time
if (%vipcheck) { haltdef }
}
raw 330:*:{
; users auth
if (%vipcheck) { haltdef }
}

How to start

2006-09-10T22:28:55Z

Saturn: /* Aliases-Tab */

This tutorial is supposed to give an introduction into scripting in mIRC. It will explain the so-called ''Scripts-Editor'' and it's functions, followed by a little example. At the end it will give some hints about how to debug a script.

== The Remote Editor ==

If you want to begin to script in mIRC, you need to open the Script-Editor. You can do it in two ways: pressing "Alt + R" or with mIRC's menubar (Tools -> Scripts Editor).

If you are using a premade script (for example nnscript), you will probably see a lot of code. Note that it is difficult to implement own scripts in such a premade one, as functions could interfere (if you want to change mIRC's default output for example).

At first, you should open a '''new remote file'''. To do it, click on File -> New (see picture below).

[[Image:Newfile.png]]

Note that your script files will be saved '''automatically'''; all you need to do is pressing 'Ok'.

The next part is about the five different tabs of mIRC's Scripts Editor:

[[Image:scriptseditortabs.png]]

=== Aliases-Tab ===

Basically, you do not need to use aliases.ini (that you can edit using this tab). Usually, if you want to add a new alias, it would look like:

[[alias]] moo { [[return]] moo }

in your 'Remote-Section' of the editor (the one that's active after pressing Alt + R).

You can add the same alias in your Aliases-Section:

moo { return moo }

Notice that you don't need to write 'alias' infront of the new alias. Note that you cannot add events in this section.

=== Popups-Tab ===

Again you do not need to use this section. It's the same as using the [[menu]] alias in the remote section. Usually, there will be some menus added in this section (for example your nicklist-menu).

[[Image:Popupsview.png]]

=== Remote-Tab ===

This is the "maintab". Every script is supposed to be saved in here.

'''Note''' that you should not have two same events in one file, as only the first matching one will be triggered. Example:

; will be triggered
on *:Text:*:*: { echo moo }

; will never be triggered
on 10:Text:*:*: { echo maa }

; will be trigger for level 10
on 10:Text:*:*: { echo maa }

; will be triggered for all but level 10
on *:Text:*:*: { echo moo }

So if you aren't sure whether it will work or not, just use another (a new) file (look above to see how to make a new file).

The following script will trigger on every "!moo" in every channel and response with "moo00oo00":

[[On_text|on *:TEXT]]:!moo:#: {
[[msg]] [[$chan]] moo00oo00
}

This would look like:

[[Image:Firstscript.png]]

If you are scripting something more complex, you want to use the "{}"-button in the upper right corner (see below).

[[Image:Bracket-button.png]]

If you've pressed it and nothing happended, everything is ok (note that it doesn't mean that your scripts will work, just that there is no obvious bracket mistake (mIRC just counts the open and closed brackets)). If something's wrong, you will get the following popup:

[[Image:Bracketerror.png]]

=== Users-Tab ===

In this file your userlist is saved. You don't need to edit it manually, as there are aliases to do so. See [[auser]], [[guser]] and [[ruser]].

=== Variables-Tab ===

All your global variables are saved in here. Again, you don't need to edit it manually, as you can use [[set]], [[unset]] or [[unsetall]].

== How to debug ==

After you've written some lines and you've tested it, you will most likely notice, that it doesn't do what you expect it to do. The next step is to '''debug''' your script. At first take a look at your Status Window and check for error messages. If there are any, search for these errors in your script and correct them. If they aren't any, you should add [[echo]]'s in your script to see where it stops to work. For example:

on *:TEXT:*:*: {
if (%moo) { echo -a we are here }
elseif (%moo2) { echo -a we are here 2 }
echo -a after the if clauses
}

With this method, you can exactly see where it stops to work and correct this part.<br>
'''Note''' You cannot trigger on text, on notice, on action... events by yourself, for that you will need someones help or another client or multiserver (/server -m ...) to test them.

[[Category:Tutorials]]

IAL-Update

2006-08-21T17:26:27Z

Saturn: scon -at1, not scon -am1

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

[[Category:IAL]][[Category:Script_Archive]]

Bread

2006-07-23T14:45:28Z

Saturn:

The bread command is used to read content from a file in to a [[Binary Files|binary file]].
<nowiki>bread [-t] <filename> <S> <N> <&binvar></nowiki>
This reads N bytes starting at the Sth byte position in the file and stores the result in the binary variable &binvar.

S is zero-based: the first byte of the file has position 0. To read the whole file, use [[$file]](<filename>).size as value for N.

The -t switch reads data up to the next CR/LF.

== Examples ==
bread versions.txt 27 100 &binvar
This will read in to the binary variable ''&binvar'' from the ''27''th position of ''versions.txt'', the follows ''100'' characters, this will include all [[$crlf]].
At the time of writing, the 27th posistion is the start of the 3rd line.
17/02/2006 - mIRC v6.17 '''Line 1''' which is 23 characters
followed by two $crlf (which is two characters each)
You can view what is in the varible with the following code:
echo -ag $bvar(&binvar,1,100)
''or''
echo -ag $bvar(&binvar,1,100).text
The latter will show you the text output as if you was looking at the information in a text editor. The first would show you the each characters ascii code. Looking at the ascii codes can help you see if the line starts with a space or see where new lines are etc.

== Note ==
Note that if you want to read from the start of the file, posistion 0 is the first character in the file.

[[Category:Binary Files]]
[[Category:Commands]]

Clear-Chanlev Script for QuakeNet

2006-04-12T21:59:45Z

Saturn: cc.remove explicitly set to $false at start now, thanks faile

Clear-Chanlev Script by Kickchon (for Q and L on QuakeNet) (v2.0)
This script removes all known users on a #channel except owners or removes Q/L completely from #channel.

; # Clear-Chanlev Script by Kickchon (for [[Q]] and [[L]] on QuakeNet) (v2.0)
; # This script removes all known users on a #channel except owners or removes Q/L completely from #channel.
; # Please do nothing after typing /clearchanlev until you get a finish/error message.
;
; # Needs Owner Access on specified #channel and you have to be authed.
; # It will not remove other Owners.
;
; # Use /clearchanlev #channel or /clearchanlev #channel -remove if you want to remove Q/L from a channel.
;
; # Kickchon, staff member on Quakenet
;
; # If you think there's a bug in this Script, please contact someone in #help.script on Quakenet.

[[Aliases|alias]] clearchanlev {
[[if-Then-Else|if]] (!$1) {
[[echo]] [[$color]](info) -at *** Clear-Chanlev: You need to specify the channel.
}
[[if-Then-Else|elseif]] (Q !ison $1) && (L !ison $1) {
echo $color(info) -at *** Clear-Chanlev: There is no Q or L bot on $1 $+ .
}
[[if-Then-Else|else]] {
set %cc.what getlname
set %cc.bot $iif(Q ison $1,Q,L)
set %cc.chan $1
if ($2 == -remove) { [[set]] %cc.remove $true }
else { [[set]] %cc.remove $false }
echo $color(info) -at *** Clear-Chanlev: Getting your %cc.bot $+ -Account Name.
.enable #clearchanlev
.[[msg]] %cc.bot whois [[$me]]
}
}

#[[Creating Groups|clearchanlev]] off

[[On_notice|on ^*:NOTICE]]:*:*:{
if ($nick == %cc.bot) {
if (%cc.what == getlname) {
if ($1 == $me) && ($3 == authed) {
set %cc.account $left($5,-1)
}
if ($1- == End of list.) {
if (%cc.account) {
echo $color(info) -at *** Clear-Chanlev: Getting Userlist of %cc.chan $+ .
set %cc.what getchanlev
.msg %cc.bot chanlev %cc.chan
}
else {
echo $color(info) -at *** Clear-Chanlev: You are not authed. Please auth before trying to clear a chanlev-list.
unset %cc.*
.[[disable]] #clearchanlev
}
}
}
elseif (%cc.what == getchanlev) {
if ($1 != %cc.account) && (End of* !iswm $1-) && (Users for channel* !iswm $1-) && (Authname* !iswm $1-) && ($1- != $str(-,29)) && $&
($1 != Channeltype:) && (Known users* !iswm $1-) {
if (n !isin $iif(%cc.bot == Q,$3,$2)) {
[[write]] clearchanlev.txt CHANLEV %cc.chan # [ $+ [ $1 ] ] $iif(%cc.bot == Q,-amotv,-amovg)
}
elseif (n isin $iif(%cc.bot == Q,$3,$2)) {
set %cc.noremove $true
}
}
elseif ($1 == %cc.account) && (n !isin [[$iif]](%cc.bot == Q,$3,$2)) {
.[[remove]] "clearchanlev.txt"
[[unset]] %cc.*
.disable #clearchanlev
echo $color(info) -at *** Clear-Chanlev: You are not the owner of that channel. Halting...
}
elseif (End* [[If-Then-Else#The_Operators|iswm]] $1-) {
if (%cc.remove) {
if (%cc.noremove) {
echo $color(info) -at *** Clear-Chanlev: You may not remove %cc.bot $+ . You are not the only owner on %cc.chan $+ .
.remove "clearchanlev.txt"
unset %cc.*
.disable #clearchanlev
[[halt]]
}
else {
write clearchanlev.txt CHANLEV %cc.chan # [ $+ [ %cc.account ] ] $iif(%cc.bot == Q,-amnotv,-amnovg)
}
}
set %cc.what removeusers
echo $color(info) -at *** Clear-Chanlev: There are $lines(clearchanlev.txt) Users to remove. It will take about $&
[[$calc]]([[$lines]](clearchanlev.txt)*2) seconds. Removing...
.[[play]] %cc.bot clearchanlev.txt 2000
}
}
[[haltdef]]
}
}

[[On_playend|on *:PLAYEND]]:{
if ([[$nopath]]([[$filename]]) == clearchanlev.txt) {
echo $color(info) -at *** Clear-Chanlev: Successfully Removed $iif(%cc.remove,$iif(%cc.bot == Q,Q,L) from,all Non-Owners on) %cc.chan $+ .
if (!%cc.remove) { .msg %cc.bot chanlev %cc.chan }
unset %cc.*
.remove "clearchanlev.txt"
.disable #clearchanlev
}
}

#clearchanlev end

[[Category:Script Archive]]
{{Author|Kickchon}}

Access Levels

2006-04-12T18:35:32Z

Saturn: and other small fixes, more commands need to be anchored here though

Access levels are assigned both to a user and to an event and serve to limit a user's access to only certain events.

The default access level is 1 for users that are not listed in the Users list. All users can access level 1 events. The higher a user's access level is, the more events that user can access. You can change the default user level to allow unlisted users to access more commands.

== Users ==
In the Users section you can specify a list of users and their access levels using the format:

<level1,level2,...,levelN>:<useraddress>
3,5,6:Dana!dana@staff.quakenet.org

The first level is a general access level, which means that the user can access all levels equal to or less than 3. All the other levels are levels that an event must specifically have to allow a user to access it.

If you want to force the first access level to be a specific level instead of a general access level, you can prefix it with an equal sign.
=3,5,6:Dana!dana@staff.quakenet.org
Now this user has access specifically to level 3, 5, and 6 event and to no other events.

== Events ==
In general, the format of an event is:
on <prefix><level>:<event>:<option/parameters>:<target>:<commands/suffix>:

on ^3:[[On_text|TEXT]]:hello:?: { [[msg]] [[$nick]] Hi, $nick }
on 5:TEXT:hello:?:=
With the exception of:
<prefix> <level>:<event>:<target>:<commands>

[[Ctcp_(event)|CTCP]] 1:HELP:*: { msg $nick No help is available for level 1 users }

''For information about the on TEXT above, please read about the [[#The_.3D_suffix|= suffix]].<br>''
The above ctcp command can be accessed by all users because it is a level 1 command. So if a user with nickname goat sends you a /[[ctcp]] yournick HELP, your script will send them the above reply.

Only the highest level matching event is triggered for a user.

== Named Levels ==
You can also used named levels which work the same way as a specific level but are easier to understand and read than a number.

friend:Dana!dana@staff.quakenet.org

on @friend:[[On_join|JOIN]]:#: { msg $nick Welcome $nick ! }

This treats the word friend as a specific access level and matches the user with the event, and because the user is your friend, you welcome them.

'''''Note:'''''<br>
You can use '''*''' as a named level that will match ''ALL'' users.

== Prefixes ==
You can limit access to an event by specifying special prefixes which determines how an event is processed or triggered by users.

=== The + prefix ===
You can limit an event to users with a specific access level by using the + prefix.

10:Dana!dana@staff.quakenet.org

ctcp +5:HELP:*: { msg $nick You have accessed a level +5 event }

The above user can't access this ctcp event even though he has an access level higher than 5, because the event is limited only to level 5 users.

=== The ! prefix ===
You can prevent an event from being triggered if it was initiated by you by using the ! prefix.

on !*:JOIN:#: { echo -tc join $chan $nick joined $chan }
You would be unable to access the above event regardless of your access level.

=== The me: prefix ===
This prefix is the negate of the ! prefix.
Using me: will only trigger the event if you are the user who triggered the event. For example:
on me:*:JOIN:#: { echo -t $chan I joined $chan }
This is the same as the following code:
on *:JOIN:#: { if ($nick == $me) { echo -t $chan I joined $chan } }
'''''Note:''''' The fact this is a three character prefix makes no difference than any other prefix.

=== The @ prefix ===
You can limit events to being executed only when you have Ops on a channel by using the @ prefix.

Blacklist:Dana!dana@staff.quakenet.org

on @Blacklist:JOIN:#: { [[mode]] $chan +b [[$address]]($nick,3) | [[kick]] $chan $nick You are blacklisted. }

When the above user joins a channel you have Ops on, the associated /mode and /kick command will be executed, in this case banning and kicking the user. If you don't have Ops, the event will not trigger.

=== The & prefix ===
You can prevent an event from being triggered if a previous script used /halt or /haltdef to halt the display of default text for an event by using the & prefix.

on &1:TEXT:*:?: { echo this event won't trigger if [[$halted]] is true }

=== The $ prefix ===
Indicates that the matchtext section of a definition contains a [[Regular_Expression]].

on $*:TEXT:m/regular expression/switches:#: { echo message: [[$1-]] }

The 'm' and switches are optional. The // are required. If switches are used they must be standard PCRE switches, otherwise the match will fail. You can use switch 'S' to strip control codes from $1-.

== Suffixes ==
Suffixes are used to prevent certain users from access the commands.

=== The = suffix ===
You can prevent users with higher access levels from accessing all lower access level events by using the = suffix.

10:Dana!dana@staff.quakenet.org

ctcp 2:HELP:*: { msg $nick You have accessed a level 2 event }
ctcp 5:HELP:*:=

The above user can't access any of these events because the level 5 event prevents him from accessing all HELP events with access levels lower than 5.
The only users who can access the above event is someone with user access level 2, 3 or 4.

=== The ! suffix ===
You can prevent commands for a certain event level from being processed by using the ! suffix.

ctcp 5:PING:*: { echo PING! }
ctcp 5:*:*:!

The ! at the end of the line tells the remote to halt any further processing of level 5 commands.

== Order of definitions ==
Many of the prefixes and controls are sensitive to numerical order of the definitions. The safest thing is to order your definitions starting with the lowest access levels first and increasing numerically down the list, this makes it easier to keep track of which events should trigger first.

== Also See ==
*[[auser]] ;Used to add a users Access Level.
*[[guser]] ;This acts the same as auser except it looks up a users ident/host via the server.
*[[flush]] ;This clears the remote user list of nickname definitions that are no longer valid.
*[[ruser]] ;Used to remove a user or a users access levels.
*[[rlevel]] ;This removes all users from the remote users list with the specified general access level.
*[[ulist]] ;This lists users which have the specified access levels.

[[Category:MIRC Help]]

Access Levels

2006-04-12T18:32:50Z

Saturn: and consistency in spacing around brackets

Access levels are assigned both to a user and to an event and serve to limit a user's access to only certain events.

The default access level is 1 for users that are not listed in the Users list. All users can access level 1 events. The higher a user's access level is, the more events that user can access. You can change the default user level to allow unlisted users to access more commands.

== Users ==
In the Users section you can specify a list of users and their access levels using the format:

<level1,level2,...,levelN>:<useraddress>
3,5,6:Dana!dana@staff.quakenet.org

The first level is a general access level, which means that the user can access all levels equal to or less than 3. All the other levels are levels that an event must specifically have to allow a user to access it.

If you want to force the first access level to be a specific level instead of a general access level, you can prefix it with an equal sign.
=3,5,6:Dana!dana@staff.quakenet.org
Now this user has access specifically to level 3, 5, and 6 event and to no other events.

== Events ==
In general, the format of an event is:
on <prefix><level>:<event>:<option/parameters>:<target>:<commands/suffix>:

on ^3:[[On_text|TEXT]]:hello:?: { [[msg]] [[$nick]] Hi, $nick }
on 5:TEXT:hello:?:=
With the exception of:
<prefix> <level>:<event>:<target>:<commands>

[[Ctcp_(event)|CTCP]] 1:HELP:*: { msg $nick No help is available for level 1 users }

''For information about the on TEXT above, please read about the [[#The_.3D_suffix|= suffix]].<br>''
The above ctcp command can be accessed by all users because it is a level 1 command. So if a user with nickname goat sends you a /[[ctcp]] yournick HELP, your script will send them the above reply.

Only the highest level matching event is triggered for a user.

== Named Levels ==
You can also used named levels which work the same way as a specific level but are easier to understand and read than a number.

friend:Dana!dana@staff.quakenet.org

on @friend:[[On_join|JOIN]]:#: { msg $nick Welcome $nick ! }

This treats the word friend as a specific access level and matches the user with the event, and because the user is your friend, you welcome them.

'''''Note:'''''<br>
You can use '''*''' as a named level that will match ''ALL'' users.

== Prefixes ==
You can limit access to an event by specifying special prefixes which determines how an event is processed or triggered by users.

=== The + prefix ===
You can limit an event to users with a specific access level by using the + prefix.

10:Dana!dana@staff.quakenet.org

ctcp +5:HELP:*: { msg $nick You have accessed a level +5 event }

The above user can't access this ctcp event even though he has an access level higher than 5, because the event is limited only to level 5 users.

=== The ! prefix ===
You can prevent an event from being triggered if it was initiated by you by using the ! prefix.

on !*:JOIN:#: { echo $chan -t $nick join joined $chan }
You would be unable to access the above event regardless of your access level.

=== The me: prefix ===
This prefix is the negate of the ! prefix.
Using me: will only trigger the event if you are the user who triggered the event. For example:
on me:*:JOIN:#: { ... }
This is the same as the following code:
on *:JOIN:#: { if ($nick == $me) { ... } }
'''''Note:''''' The fact this is a three character prefix makes no difference than any other prefix.

=== The @ prefix ===
You can limit events to being executed only when you have Ops on a channel by using the @ prefix.

Blacklist:Dana!dana@staff.quakenet.org

on @Blacklist:JOIN:#: { [[mode]] $chan +b [[$address]]($nick,3) | [[kick]] $chan $nick You are blacklisted. }

When the above user joins a channel you have Ops on, the associated /mode and /kick command will be executed, in this case banning and kicking the user. If you don't have Ops, the event will not trigger.

=== The & prefix ===
You can prevent an event from being triggered if a previous script used /halt or /haltdef to halt the display of default text for an event by using the & prefix.

on &1:TEXT:*:?: { echo this event won't trigger if [[$halted]] is true }

=== The $ prefix ===
Indicates that the matchtext section of a definition contains a [[Regular_Expression]].

on $*:TEXT:m/regular expression/switches:#: { echo message: [[$1-]] }

The 'm' and switches are optional. The // are required. If switches are used they must be standard PCRE switches, otherwise the match will fail. You can use switch 'S' to strip control codes from $1-.

== Suffixes ==
Suffixes are used to prevent certain users from access the commands.

=== The = suffix ===
You can prevent users with higher access levels from accessing all lower access level events by using the = suffix.

10:Dana!dana@staff.quakenet.org

ctcp 2:HELP:*: { msg $nick You have accessed a level 2 event }
ctcp 5:HELP:*:=

The above user can't access any of these events because the level 5 event prevents him from accessing all HELP events with access levels lower than 5.
The only users who can access the above event is someone with user access level 2, 3 or 4.

=== The ! suffix ===
You can prevent commands for a certain event level from being processed by using the ! suffix.

ctcp 5:PING:*: { echo PING! }
ctcp 5:*:*:!

The ! at the end of the line tells the remote to halt any further processing of level 5 commands.

== Order of definitions ==
Many of the prefixes and controls are sensitive to numerical order of the definitions. The safest thing is to order your definitions starting with the lowest access levels first and increasing numerically down the list, this makes it easier to keep track of which events should trigger first.

== Also See ==
*[[auser]] ;Used to add a users Access Level.
*[[guser]] ;This acts the same as auser except it looks up a users ident/host via the server.
*[[flush]] ;This clears the remote user list of nickname definitions that are no longer valid.
*[[ruser]] ;Used to remove a user or a users access levels.
*[[rlevel]] ;This removes all users from the remote users list with the specified general access level.
*[[ulist]] ;This lists users which have the specified access levels.

[[Category:MIRC Help]]

Access Levels

2006-04-12T18:31:47Z

Saturn: and added some consistency in use of #channel

Access levels are assigned both to a user and to an event and serve to limit a user's access to only certain events.

The default access level is 1 for users that are not listed in the Users list. All users can access level 1 events. The higher a user's access level is, the more events that user can access. You can change the default user level to allow unlisted users to access more commands.

== Users ==
In the Users section you can specify a list of users and their access levels using the format:

<level1,level2,...,levelN>:<useraddress>
3,5,6:Dana!dana@staff.quakenet.org

The first level is a general access level, which means that the user can access all levels equal to or less than 3. All the other levels are levels that an event must specifically have to allow a user to access it.

If you want to force the first access level to be a specific level instead of a general access level, you can prefix it with an equal sign.
=3,5,6:Dana!dana@staff.quakenet.org
Now this user has access specifically to level 3, 5, and 6 event and to no other events.

== Events ==
In general, the format of an event is:
on <prefix><level>:<event>:<option/parameters>:<target>:<commands/suffix>:

on ^3:[[On_text|TEXT]]:hello:?: { [[msg]] [[$nick]] Hi, $nick }
on 5:TEXT:hello:?:=
With the exception of:
<prefix> <level>:<event>:<target>:<commands>

[[Ctcp_(event)|CTCP]] 1:HELP:*: { msg $nick No help is available for level 1 users }

''For information about the on TEXT above, please read about the [[#The_.3D_suffix|= suffix]].<br>''
The above ctcp command can be accessed by all users because it is a level 1 command. So if a user with nickname goat sends you a /[[ctcp]] yournick HELP, your script will send them the above reply.

Only the highest level matching event is triggered for a user.

== Named Levels ==
You can also used named levels which work the same way as a specific level but are easier to understand and read than a number.

friend:Dana!dana@staff.quakenet.org

on @friend:[[On_join|JOIN]]:#: { msg $nick Welcome $nick ! }

This treats the word friend as a specific access level and matches the user with the event, and because the user is your friend, you welcome them.

'''''Note:'''''<br>
You can use '''*''' as a named level that will match ''ALL'' users.

== Prefixes ==
You can limit access to an event by specifying special prefixes which determines how an event is processed or triggered by users.

=== The + prefix ===
You can limit an event to users with a specific access level by using the + prefix.

10:Dana!dana@staff.quakenet.org

ctcp +5:HELP:*: { msg $nick You have accessed a level +5 event }

The above user can't access this ctcp event even though he has an access level higher than 5, because the event is limited only to level 5 users.

=== The ! prefix ===
You can prevent an event from being triggered if it was initiated by you by using the ! prefix.

on !*:JOIN:#: { echo $chan -t $nick join joined $chan }
You would be unable to access the above event regardless of your access level.

=== The me: prefix ===
This prefix is the negate of the ! prefix.
Using me: will only trigger the event if you are the user who triggered the event. For example:
on me:*:JOIN:#:{ ... }
This is the same as the following code:
on *:JOIN:#:{ if ($nick == $me) { ... } }
'''''Note:''''' The fact this is a three character prefix makes no difference than any other prefix.

=== The @ prefix ===
You can limit events to being executed only when you have Ops on a channel by using the @ prefix.

Blacklist:Dana!dana@staff.quakenet.org

on @Blacklist:JOIN:#: { [[mode]] $chan +b [[$address]]($nick,3) | [[kick]] $chan $nick You are blacklisted. }

When the above user joins a channel you have Ops on, the associated /mode and /kick command will be executed, in this case banning and kicking the user. If you don't have Ops, the event will not trigger.

=== The & prefix ===
You can prevent an event from being triggered if a previous script used /halt or /haltdef to halt the display of default text for an event by using the & prefix.

on &1:TEXT:*:?: { echo this event won't trigger if [[$halted]] is true }

=== The $ prefix ===
Indicates that the matchtext section of a definition contains a [[Regular_Expression]].

on $*:TEXT:m/regular expression/switches:#: { echo message: [[$1-]] }

The 'm' and switches are optional. The // are required. If switches are used they must be standard PCRE switches, otherwise the match will fail. You can use switch 'S' to strip control codes from $1-.

== Suffixes ==
Suffixes are used to prevent certain users from access the commands.

=== The = suffix ===
You can prevent users with higher access levels from accessing all lower access level events by using the = suffix.

10:Dana!dana@staff.quakenet.org

ctcp 2:HELP:*: { msg $nick You have accessed a level 2 event }
ctcp 5:HELP:*:=

The above user can't access any of these events because the level 5 event prevents him from accessing all HELP events with access levels lower than 5.
The only users who can access the above event is someone with user access level 2, 3 or 4.

=== The ! suffix ===
You can prevent commands for a certain event level from being processed by using the ! suffix.

ctcp 5:PING:*: { echo PING! }
ctcp 5:*:*:!

The ! at the end of the line tells the remote to halt any further processing of level 5 commands.

== Order of definitions ==
Many of the prefixes and controls are sensitive to numerical order of the definitions. The safest thing is to order your definitions starting with the lowest access levels first and increasing numerically down the list, this makes it easier to keep track of which events should trigger first.

== Also See ==
*[[auser]] ;Used to add a users Access Level.
*[[guser]] ;This acts the same as auser except it looks up a users ident/host via the server.
*[[flush]] ;This clears the remote user list of nickname definitions that are no longer valid.
*[[ruser]] ;Used to remove a user or a users access levels.
*[[rlevel]] ;This removes all users from the remote users list with the specified general access level.
*[[ulist]] ;This lists users which have the specified access levels.

[[Category:MIRC Help]]

Access Levels

2006-04-12T18:30:56Z

Saturn: added example to me: prefix

Access levels are assigned both to a user and to an event and serve to limit a user's access to only certain events.

The default access level is 1 for users that are not listed in the Users list. All users can access level 1 events. The higher a user's access level is, the more events that user can access. You can change the default user level to allow unlisted users to access more commands.

== Users ==
In the Users section you can specify a list of users and their access levels using the format:

<level1,level2,...,levelN>:<useraddress>
3,5,6:Dana!dana@staff.quakenet.org

The first level is a general access level, which means that the user can access all levels equal to or less than 3. All the other levels are levels that an event must specifically have to allow a user to access it.

If you want to force the first access level to be a specific level instead of a general access level, you can prefix it with an equal sign.
=3,5,6:Dana!dana@staff.quakenet.org
Now this user has access specifically to level 3, 5, and 6 event and to no other events.

== Events ==
In general, the format of an event is:
on <prefix><level>:<event>:<option/parameters>:<target>:<commands/suffix>:

on ^3:[[On_text|TEXT]]:hello:?: { [[msg]] [[$nick]] Hi, $nick }
on 5:TEXT:hello:?:=
With the exception of:
<prefix> <level>:<event>:<target>:<commands>

[[Ctcp_(event)|CTCP]] 1:HELP:*: { msg $nick No help is available for level 1 users }

''For information about the on TEXT above, please read about the [[#The_.3D_suffix|= suffix]].<br>''
The above ctcp command can be accessed by all users because it is a level 1 command. So if a user with nickname goat sends you a /[[ctcp]] yournick HELP, your script will send them the above reply.

Only the highest level matching event is triggered for a user.

== Named Levels ==
You can also used named levels which work the same way as a specific level but are easier to understand and read than a number.

friend:Dana!dana@staff.quakenet.org

on @friend:[[On_join|JOIN]]:#: { msg $nick Welcome $nick ! }

This treats the word friend as a specific access level and matches the user with the event, and because the user is your friend, you welcome them.

'''''Note:'''''<br>
You can use '''*''' as a named level that will match ''ALL'' users.

== Prefixes ==
You can limit access to an event by specifying special prefixes which determines how an event is processed or triggered by users.

=== The + prefix ===
You can limit an event to users with a specific access level by using the + prefix.

10:Dana!dana@staff.quakenet.org

ctcp +5:HELP:*: { msg $nick You have accessed a level +5 event }

The above user can't access this ctcp event even though he has an access level higher than 5, because the event is limited only to level 5 users.

=== The ! prefix ===
You can prevent an event from being triggered if it was initiated by you by using the ! prefix.

on !*:JOIN:#: { echo $chan -t $nick join joined $chan }
You would be unable to access the above event regardless of your access level.

=== The me: prefix ===
This prefix is the negate of the ! prefix.
Using me: will only trigger the event if you are the user who triggered the event. For example:
on me:*:JOIN:#channel:{ ... }
This is the same as the following code:
on *:JOIN:#channel:{ if ($nick == $me) { ... } }
'''''Note:''''' The fact this is a three character prefix makes no difference than any other prefix.

=== The @ prefix ===
You can limit events to being executed only when you have Ops on a channel by using the @ prefix.

Blacklist:Dana!dana@staff.quakenet.org

on @Blacklist:JOIN:#: { [[mode]] $chan +b [[$address]]($nick,3) | [[kick]] $chan $nick You are blacklisted. }

When the above user joins a channel you have Ops on, the associated /mode and /kick command will be executed, in this case banning and kicking the user. If you don't have Ops, the event will not trigger.

=== The & prefix ===
You can prevent an event from being triggered if a previous script used /halt or /haltdef to halt the display of default text for an event by using the & prefix.

on &1:TEXT:*:?: { echo this event won't trigger if [[$halted]] is true }

=== The $ prefix ===
Indicates that the matchtext section of a definition contains a [[Regular_Expression]].

on $*:TEXT:m/regular expression/switches:#: { echo message: [[$1-]] }

The 'm' and switches are optional. The // are required. If switches are used they must be standard PCRE switches, otherwise the match will fail. You can use switch 'S' to strip control codes from $1-.

== Suffixes ==
Suffixes are used to prevent certain users from access the commands.

=== The = suffix ===
You can prevent users with higher access levels from accessing all lower access level events by using the = suffix.

10:Dana!dana@staff.quakenet.org

ctcp 2:HELP:*: { msg $nick You have accessed a level 2 event }
ctcp 5:HELP:*:=

The above user can't access any of these events because the level 5 event prevents him from accessing all HELP events with access levels lower than 5.
The only users who can access the above event is someone with user access level 2, 3 or 4.

=== The ! suffix ===
You can prevent commands for a certain event level from being processed by using the ! suffix.

ctcp 5:PING:*: { echo PING! }
ctcp 5:*:*:!

The ! at the end of the line tells the remote to halt any further processing of level 5 commands.

== Order of definitions ==
Many of the prefixes and controls are sensitive to numerical order of the definitions. The safest thing is to order your definitions starting with the lowest access levels first and increasing numerically down the list, this makes it easier to keep track of which events should trigger first.

== Also See ==
*[[auser]] ;Used to add a users Access Level.
*[[guser]] ;This acts the same as auser except it looks up a users ident/host via the server.
*[[flush]] ;This clears the remote user list of nickname definitions that are no longer valid.
*[[ruser]] ;Used to remove a user or a users access levels.
*[[rlevel]] ;This removes all users from the remote users list with the specified general access level.
*[[ulist]] ;This lists users which have the specified access levels.

[[Category:MIRC Help]]

Category:Hash Table

2006-04-12T00:06:11Z

Saturn: /* Deleting unwanted items from a hash table */

== Basic Defintion ==
Basically, hash tables are like [[:Category:Ini|ini files]], storing information in following format:

<b>Tablename</b><br />
item1=data1<br />
item2=data2<br />
...

However, hash tables are a lot faster than ini- or text-files, which especially takes effect if you have a lot of entries. A kind of disadvantage is the missing possibility to ''see'' all entries. With some files, you can just open them and take a look on every entry, whereat hash table, you can't just ''open'' then. To have the chance to still get an overview, you can use the following script:

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

=== Modifying hash tables ===
You can make a new hashtable using the [[Hmake|/hmake]], respectivly delete one using the [[Hfree|/hfree]] command. Using [[Hdel|/hdel]] and [[Hadd|/hadd]], you can modify the data saved in your hashtable. Due to hash tables not being automatically saved, you have to use the [[Hsave|/hsave]] and [[Hload|/hload]] command.

=== Receiving data ===
After saving data in hash tables, you can of course receive them. Therefor, use the [[$hget]] and [[$hfind]] identifiers.

== More detailed information ==

The following explanations aren't necessary for using hashtables in mIRC scripts, however, these facts could help you make your scripts faster, especially if you are going to use hash tables for a lot of data.

A hashtable is basically an array of N buckets (N being the size from /hmake) where each bucket is just a pointer (4 bytes) to a linked list of items. In principle you could enlarge the number of buckets later on by resizing the array, but that means the hash values for items change: the bucket number for an item, i.e. the index into the array of pointers, is determined by the formula "hashfunc(itemname) modulo N". Changing N on the fly essentially means you have to reassign most of the items to other buckets, which is a nightmare with large hashtables.

This means that $hget will indeed be slower if you take a smaller hashtable and fill it with the same amount of items as before, since the average amount of items to traverse in a bucket when looking for a match is N/2, which would mean that $hget takes much longer on a big file loaded in a small hash table, compared to a big file loaded in a big hash table.
A benchmark would show this, although you'd have to repeat $hget a large number of times of course, as the speed of individual $hgets is still negligible.

On the other hand, if your file contains M entries, /hload does M implicit $hgets to ensure that item names won't be added twice. If the factor M:N (i.e. items:size) is 10:1, then it will do (on average) 5 * M lookups, if it is 100:1, then it will do 50 * M lookups and so on. For large values of M, this difference is noticeable, even with one single /hload. So you should choose N very carefully before issuing a /hload.

Note that there is no such thing as an "overflow" in hashtables; buckets point to linked lists that can be of arbitrary length. If you make a hashtable of size 1, you are essentially using a single linked list of items, and everything will still work fine (but $hget would be just as slow as $hfind in that case).

== Deleting unwanted items from a hash table ==

In some cases, you'll want to loop over ''all'' the items in the hashtable, deleting the ones you do not want anymore. It may be a bit unclear at first how to do this: deleting items while looping over them is kind of like removing the ground under your own feet; how can you be sure you don't end up skipping over items, for example?

Fortunately, there's one fundamental fact that you can use to do this: if you loop over N items using $hget().item, and then delete the N+1'th item, then those N items will remain the same. The N+1'th item, though, will be a new item (typically the N+2'th item). For example, if $hget().item returns A, B, C and D for respectively N values 1, 2, 3 and 4. and then you delete item C, then you can be sure that $hget().item with N values 1 and 2 will still return A and B after deleting C, respectively. Item D, however, will now be item 3 instead of 4, because there will never be any "gaps" between item numbers.

The following alias shows how to put this into practice, by looping over all the items in a given hashtable, and calling a custom identifier $want-to-delete on each of them, deleting the items for which $want-to-delete returns $true. The loop will always complete (no infinite loop!), and after it has completed, ''all'' the items that were to be deleted, will indeed be gone.

; usage: /purgeitems <hashtable>
[[alias]] purgeitems {
; our counter: we start off at the first item
[[var]] %i = 1
;
; as long as the %i-th item exists, continue looping
[[while]] ($hget($1,%i).item != $null) {
; temporarily store the name of this item in a variable
; $v1 refers to the "$hget($1,%i).item" bit above
[[var]] %t = $v1
;
; now perform a check to see if we still want to keep this item;
; $want-to-delete is a custom alias (not included) and returns
; either $true or $false, indicating whether we should delete %t
[[if]] ($want-to-delete(%t)) {
; yes, we want to delete this item; use its item name (%t) to
; actually delete it using /hdel
[[hdel]] $1 %t
;
; the important part is that we do NOT increase %i here;
; we just deleted the %i-th item, so the %i-th item is now a
; new item. due to the way hashtable iteration works, we also
; know for sure that we have not seen the %i-th item yet!
}
[[else]] {
; we're leaving this item in, so let's increase %i so that we
; move on to the next item.
[[inc]] %i
}
}
}

Note that this is a very expensive (slow) operation, you should not use $hget().item unless you have to. If you can, use [[hdel|/hdel]] with the -w (wildcard) switch instead!
[[Category:MIRC Help]]

Category:Hash Table

2006-04-12T00:01:41Z

Saturn: from the between-1am-and-2am dept.: added "deleting unwanted items" bit

Unbannick

2006-04-03T14:49:43Z

Saturn: oops.

{{Stub}}
This script provides an alias to unban a "nick" (respectivly his address) even if this user isn't on the channel. Therefor, it uses the [[who|/who]] command to get the current address of a nickname.

The syntax is: /unbannick <channel> <nickname>

Additionally, it will drop the one unbanning this nick a message and the one that got unbanned a notice. The part about uhexec will be without further comments.

; on disconnect we clear the hashtable uhexec has used.
[[On_disconnect|on *:DISCONNECT]]:[[if]] ($hget(uhexec)) [[hdel]] -w uhexec $cid $+ .*
[[alias]] -l uhq [[return]] [[$iif]]([[$hget]](uhexec,$+($cid,.,[[$1]])),$v1,$iif($1 !isnum,0))
alias -l uhnext {
$iif($0 > 1,hadd -m,hdel) uhexec $+($cid,.,$uhq($1) $2-)
[[hadd]] uhexec $+($cid,.,$1) $iif($uhq($1) < 64,$calc($v1 + 1),0)
}
alias -l uhexec {
[[if]] ([[$status]] == connected) || ([[$ial]]($1).addr != [[$null]]) {
uhnext head $1-
[[userhost]] $1
}
[[else]] $2- $ial($1).addr
}
[[Raw_302|raw $302]]:/^\S+( (\S+?)\*?=[+-](\S+)|) ?$/:{
[[tokenize]] 32 $uhq($uhq(tail))
if ($0) && (([[$regml]](0) < 2) || ($1 == $regml(2))) {
uhnext tail
$2- $regml(3)
[[halt]]
}
}
alias -l uncb {
; <chan> <nick> [host]
if ($3 == $null) return
[[var]] %i = 1, %b, %a = $+($2,!,$3)
[[while]] ($ibl($1,%i) != $null) {
if ($v1 iswm %a) {
%b = %b $v1
if ([[$numtok]](%b,32) == [[$modespl]]) {
[[mode]] $1 - $+ [[$str]](b,$numtok(%b,32)) %b
%b =
}
}
[[inc]] %i
}
if (%b != $null) mode $1 - $+ $str(b,$numtok(%b,32)) %b
[[msg]] $1 Unbanned $2 upon request
[[notice]] $2 You're now unbanned on $1
}
; actually provide the alias (Syntax: /unbannick <chan> <nick>)
alias unbannick uhexec $2 uncb $1-2

[[Category:Script Archive]]

Mailcheck

2006-04-01T10:00:39Z

Saturn: small bug fixed, thanks to ArKanis

This script is supposed to check your POP3 mailaccount and return whether you have new mails or not.
You will find a little alias at the beginning where you have to put your login details in.

; this is the alias where you have to put your login details in by replacing the <...>.
; lets actually make a new alias called mailoptions
[[alias]] mailoptions {
; check if we get something like $mailoptions(emailserver) or $mailoptions(emailport) and return it
; like pop.gmx.net
[[if]] ([[$1-|$1]] == emailserver) { [[return]] <your email server> }
; this is normally 110
elseif ($1 == emailport) { return <your email port> }
; probably your email address
elseif ($1 == emailuser) { return <your email user> }
; this is your password
elseif ($1 == emailpass) { return <your email pass> }
}

; this is the alias you can use to start checking your account
; lets make another alias called mailcheck
alias mailcheck {
; at first we need to check if all details are given. Only if they are, we will continue
if ($mailoptions(emailserver)) && ($mailoptions(emailport)) && (mailsoptions(emailuser)) && (mailsoptions(emailpass)) {
; this command will close a socket called "mailcheck" if one exists.
[[sockclose]] mailcheck
; here we open a new socket called mailcheck to our server on the given port
[[sockopen]] mailcheck $mailoptions(emailserver) $mailoptions(emailport)
; we set a variable for a later alias
set %mailcheck_var 0
}
}

; this event will trigger if the new socket called mailcheck has been opened
[[On_sockopen|on *:Sockopen]]:mailcheck: {
; lets check if there are any errors, if they are, echo it and halt
if ([[$sockerr]] > 0) { [[echo]] -a ERROR | [[halt]] }
}

; this event will trigger when we receive any data through the socket
[[On_sockread|on *:Sockread]]:mailcheck: {
; sockread will put the data in a variable, here %temp
[[sockread]] %temp
; the alias mailcheck_read, that we will define later, is supposed to handle eveerything we receive
mailcheck_read %temp
}

; this is the alias mailcheck_read that will handle everything
; lets start it
alias mailcheck_read {
; increase the %mailcheck_var variable, we have set to 0 in the mailcheck alias, once everytime we get some new data
[[inc]] %mailcheck_var 1
; we check if $1 is +OK. Read the pop3 protocol to get more info about it
if $1 == +OK {
; if its the first time we get some data, send "user <username>" to the socket.
if (%mailcheck_var == 1) { .[[sockwrite]] -n mailcheck user $mailoptions(emailuser) }
; after that, we need to send our password
if (%mailcheck_var == 2) { .sockwrite -n mailcheck pass $mailoptions(emailpass) }
; after sending username and password, we need to tell the server what we actually want to do. We want to know if there are new emails. So send "stat".
if (%mailcheck_var == 3) { .sockwrite -n mailcheck stat }
; if we are here, %temp will contain whether we have new mails or now. $2 is the number of new mails, being 0 or 1 or any other number.
if (%mailcheck_var == 4) {
; lets echo this to the status window
echo -s New mails: $2
; closing the socket at the end as we are done
sockclose mailcheck
}
}
}

[[Category:Script Archive]]
[[Category:Socket]]

If-Then-Else

2006-03-27T22:42:05Z

Saturn: /* The Operators */

__NOTOC__
The If-then-else statement allows you to compare values and execute different parts of a script based on that comparison.

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 return
B If B is true,
\
C check if C, D or E returns true
D
E
F If none of these got triggered, return F
G G is checked only if A or B were not triggered
H If none of previous wasn't matches, H is returned

== The Operators ==

[[#==|==]] equal to
[[#==|===]] equal to (case-sensitive)
[[#!=|!=]] not equal to
[[#<|<]] 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

[[#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).

=== != ===
if (cat != cAt) ;Returns false since != is case-insensitive and both values v1 and v2 are equal.
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.
The != and !== operators are the negates of the == and === operators.

=== < ===
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 less 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 multipul of 9.
Multipuls 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 multipul of 9.
\\ is the negate of //

=== & ===
if (13 & 4) ;Returns true because the 4th bit of 13 is [[$biton|turned on]].
& Is a bitwise comparison and checks thats bit v2 (4) is 'turned on' in v1.
Using & operator is the same as using [[$isbit]].

=== isin ===
if (cat isin [[$1-]])
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 dont love you" since "dont love" contains a space.

=== isnum ===

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

The Examples above checks $1 if, 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 upper 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.

=== 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.

=== ishop ===
if (moo ishop #mIRC) ; returns true if ''moo'' is an half operator in #mIRC
'''Note''' that QuakeNet does not support halfops.

=== 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.

=== 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.

=== 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- only contain uppercase letters. So ABCD returns true, but even one lowercase letter makes it return false.

====''This article covers only if-then-else '''string''' operators''====
You '''can't''' use
if (foo isin test.txt)
To check content of text-files. You can use [[$read]] instead to read the content of a text file and then use the return value returned by that $read.

[[Category:Commands]]

If-Then-Else

2006-03-27T22:41:38Z

Saturn: /* isban */

__NOTOC__
The If-then-else statement allows you to compare values and execute different parts of a script based on that comparison.

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 return
B If B is true,
\
C check if C, D or E returns true
D
E
F If none of these got triggered, return F
G G is checked only if A or B were not triggered
H If none of previous wasn't matches, H is returned

== The Operators ==

[[#==|==]] equal to
[[#==|===]] equal to (case-sensitive)
[[#!=|!=]] not equal to
[[#<|<]] 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

[[#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 internal ban list

[[#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).

=== != ===
if (cat != cAt) ;Returns false since != is case-insensitive and both values v1 and v2 are equal.
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.
The != and !== operators are the negates of the == and === operators.

=== < ===
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 less 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 multipul of 9.
Multipuls 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 multipul of 9.
\\ is the negate of //

=== & ===
if (13 & 4) ;Returns true because the 4th bit of 13 is [[$biton|turned on]].
& Is a bitwise comparison and checks thats bit v2 (4) is 'turned on' in v1.
Using & operator is the same as using [[$isbit]].

=== isin ===
if (cat isin [[$1-]])
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 dont love you" since "dont love" contains a space.

=== isnum ===

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

The Examples above checks $1 if, 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 upper 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.

=== 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.

=== ishop ===
if (moo ishop #mIRC) ; returns true if ''moo'' is an half operator in #mIRC
'''Note''' that QuakeNet does not support halfops.

=== 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.

=== 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.

=== 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- only contain uppercase letters. So ABCD returns true, but even one lowercase letter makes it return false.

====''This article covers only if-then-else '''string''' operators''====
You '''can't''' use
if (foo isin test.txt)
To check content of text-files. You can use [[$read]] instead to read the content of a text file and then use the return value returned by that $read.

[[Category:Commands]]

User:Saturn

2006-01-30T16:07:43Z

Saturn: yearly update

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

<table border="0">
<tr>
<td>[[Image:Saturn.png]]</td>
<td>
<table border="0">
<tr><td><b>Name</b></td><td>David van Moolenbroek</td></tr>
<tr><td><b>Age</b></td><td>23</td></tr>
<tr valign="top" height="40"><td><b>Country</b></td><td>The Netherlands</td></tr>

<tr><td><b>Words of wisdom</b></td><td>The eyes of truth are always watching you.</td></tr>
</table>
</td>
</tr>
</table>
[[Category:Members]]

Main Page

2006-01-27T14:14:59Z

Saturn: well, um, actually i can do that too

== This Wiki ==

Welcome to the Scriptwiki, a wiki dedicated to mIRC scripting! Here, you can find information and reference material to help you write scripts for mIRC; we have information ranging from simple tutorials to extensive mIRC help, and also a number of prefabricated scripts.

In contrast to many other wikis, here normal users aren't allowed to make changes to the wiki. This way, we can ensure a certain level of quality. You are totally free to read the material, but if you want to contribute to this wiki, you need to be approved as a wiki editor. You can become a wiki editor in either of the following two ways:
* Be invited by an [[Members|existing wiki editor]] (or an admin) and approved by the admins. Or,
* Write an example article for us, to show us your writing skills. It will be evaluated by the admins and you will be notified if the result is positive. You must submit your article [[Special:BeMember|here]], along with some personal details.

== Script Archive ==

You can find several prefabricated scripts in our [[:Category:Script Archive|Script Archive]], which serve as examples and can be used to build more complex scripts.

== mIRC help ==

If you're not sure how a command or an identifier works, you can check it from our [[:Category:MIRC_Help|mIRC Help]] pages.

== Tutorials ==

Our [[:Category:Tutorials|tutorials]] aim to provide a step-by-step introduction to various mIRC scripting related topics.

------

This wiki is a project launched by [http://script.quakenet.org #help.script] on [http://www.quakenet.org QuakeNet].
__NOTOC__

Main Page

2006-01-27T14:09:49Z

Saturn: needs some links to uh, somewhere, i suppose

Main Page

2006-01-19T22:27:02Z

Saturn: /* This Wiki */

Main Page

2006-01-19T22:23:07Z

Saturn: /* This Wiki */

== This Wiki ==

Welcome to the Scriptwiki, a wiki dedicated to mIRC scripting! Here, you can find information and reference material to help you write scripts for mIRC; we have information ranging from simple tutorials to extensive mIRC help, and also a number of prefabricated scripts.

In contrast to many other wikis, here normal users aren't allowed to make changes to the wiki. This way, we can ensure a certain level of quality. You are totally free to read the material, but if you want to contribute to this wiki, you need to be approved as a wiki editor. You can become a wiki editor in either of the following two ways:
* Be invited by an [[Members|existing wiki editor]] (or an admin) and approved by the admins. Or,
* Write an example article for us, to show us your writing skills. It will be evaluated by the admins and you will be notified if the result is positive. You must submit your article, along with some personal details, [[Special:BeMember|here]].

== Script Archive ==

You can find several prefabricated scripts in our [[:Category:Script Archive|Script Archive]], which serve as examples and can be used to build more complex scripts.

== mIRC help ==

If you're not sure how a command or an identifier works, you can check it from our [[:Category:MIRC_Help|mIRC Help]] pages.

== Tutorials ==

Our [[:Category:Tutorials|tutorials]] aim to provide a step-by-step introduction to various mIRC scripting related topics.
__NOTOC__

Category:File Handling

2005-12-22T23:58:17Z

Saturn: slightly better hopefully?

== General Explanation ==
In addition to several high-level file access methods, mIRC offers a low-level way of accessing files, which closely resembles the way that operating systems like Windows or UNIX allow programs to access files. The individual commands and identifiers in this category allow you to open a file, perform a number of (read/write) operations on it, and close it.

First of all you have to open a file using [[Fopen|/fopen]]. When doing this, you have to specify a handle - in subsequent commands you can use this handle to refer to the open file. The handle is just a name that you, the scripter, can choose yourself. This is similar to how [[:Category:Socket|socket]] names work.

Each open file has a ''file pointer''. This file pointer is the current byte position in the file, and the read/write commands will always work from this position. Additionally, those commands will move the file pointer forward with as many bytes as they read/write. For example, if the file pointer is at byte 1055, and you use [[$fgetc]], then you will get the 1055th byte of the file, and the file pointer will move to 1056. When you've just opened the file, the file pointer is set to the start of the file (byte 0); you can manually move the pointer to another position in the file by using [[Fseek|/fseek]].

mIRC will lock an opened file from being accessed by other programs for as long as the file handle is open. After you've used a file, you '''have to''' close it again, using [[Fclose|/fclose]]. That will write any changes you made to disk, and unlock the file.

'''Note''' that you should check [[$ferr]] after every operation on the file (including opening it!).

== Difference to /write and $read ==
Contrary to this, the "usual" way to access a file ([[Write|/write]] and [[$read]] that is) work in another way. For example, if you want to echo line number 4 and 5 of a file, you would use:
[[echo]] -a $read(my.txt,4) $read(my.txt,5)
Internally, mIRC would do following:
#open the file (using fopen)
#read the first line (using $fread - check [[$read]] for more details about it)
#move the pointer to the start of line 4 (using fseek)
#read this line (using $fread)
#close the file (using fclose)
#open the file again (using fopen)
#move the pointer to the start of line 5 (using fseek)
#read this line (using $fread)
#close the file (using fclose) again

That's obviously not efficient, as we don't need to close it after our first read. So using File Handling, we could directly do:
#open the file (using fopen)
#jump to line 4 (using fseek)
#read this line (using fread)
#read the next line (and the pointer is automatically there after reading line 4 - using fread)
#close the file (using flose)
If you want to read one or two lines only, there is no need to use this way, as $read is alot easier to handle, but if you have a file of e.g. 40mb and want to read 100 lines, there is a ''big'' difference between File Handling and $read (~ factor 10).
== Example ==

[[Category:mIRC Help]]

Local Variables

2005-11-10T14:50:06Z

Saturn: rewrite

Local variables are variables that exist only for the duration of the piece of script (for example an alias or event) in which they are created, and can only be accessed from within ''that'' piece of script - not from other anywhere else, not even from the aliases that the piece of script calls. Local variables are removed automatically when the piece of script is finished, so it is not required to /[[unset]] them. Local variables are very useful for storing short-lived data, such as loop counters and temporary results.

Local variables can be created with the /var command:
var %myvar = somevalue

Note that a local variable and a global variable (created with /[[set]]) with the same name may exist; in that case, the local variable will be used in the piece of script, and the global variable will not be changed.

You can set multiple variables at once:
var %x = foo, %y = bar

Although the '=' can be left out from the /var command in some cases, it is bad practice to do so: it can lead to weird errors in other lines.

You can use /var -s to make a variable show the result when a value is set.

Do not use /var to create local variables with a dynamic name (e.g. ''%x [ $+ [ %y ] ]''), there is a bug in mIRC that prevents you from doing this.

== Examples ==

First, let's create an [[Aliases|alias]] that's used later on.
alias var_example { var -s %x = foo | set -s %y bar }

Now, let's play around.

; set values to variables with set so values exists until they're unset
set %x 10
set %y %x
; value from %x is copied to %y

; call of your own alias
var_example
; displays
; * Set %x to foo
; * Set %y to bar

; now, let's display %x and %y values
[[echo]] -a %x
; returns 10
echo -a %y
; returns bar

As we can see, %x still holds its original value because /var only creates a local variable, but %y was overwritten with /set.

{{Author|Tovrleaf}}

[[Category:Variables]]

Inc

2005-11-10T14:12:49Z

Saturn: /inc'ed grammar

This increases the value of %var by value.

/inc [-cszuN] <%var> [value]

Options explained:
uN - increases %var once and [[unset|unsets]] it N seconds later.
z - decreases %var until it reaches zero and then unsets it.
s - displays action in status window
c - increases %var once per second.

If no value is given, default value is 1.

== Example ==

The /inc command is commonly used in [[While_loops|loops]].
var %c = 1
while (%c <= 4) {
; do something
; continue, commands etc..
inc %c
}

Displays %c's values from 1 to 4.
More advanced example, just playing around.

1 alias exam_inc {
2 [[set]] -s %x 1
3 while (%x < 5) {
4 inc -s %x
5 }
6 while (%x > 2) {
7 inc -s %x -1
8 }
9 inc -sz %x 2
10 }

In the following results the line numbers are added after ;. The results are:
* Set %x to 1 ; 1
* Inc %x to 2 ; 2-5
* Inc %x to 3 ; 2-5
* Inc %x to 4 ; 2-5
* Inc %x to 5 ; 2-5
* Inc %x to 4 ; 6-8
* Inc %x to 3 ; 6-8
* Inc %x to 2 ; 6-8
* Inc %x to 4 ; 9 (notice increase with 2)
* Inc %x to 3 ; 9
* Inc %x to 2 ; 9
* Inc %x to 1 ; 9
* Unset %x ; 9 (switch z unsets)

== See Also ==

To decrease a value, you can also use [[dec]].

{{Author|Tovrleaf}}

[[Category:Variables]]

Inc

2005-11-10T14:12:11Z

Saturn: Reverted edit of Saturn, changed back to last version by Microbe

This increases the value of %var by value.

/inc [-cszuN] <%var> [value]

Options explained:
uN - increases %var once and [[unset|unsets]] it N seconds later.
z - decreases %var until it reaches zero and then unsets it.
s - displays action in status window
c - increases %var once per second.

If no value is given, default value is 1.

== Example ==

Increase is commonly used in [[While_loops|loops]].
var %c = 1
while (%c <= 4) {
; do something
; continue, commands etc..
inc %c
}

Displays %c's values from 1 to 4.
More advantages example, just playing around.

1 alias exam_inc {
2 [[set]] -s %x 1
3 while (%x < 5) {
4 inc -s %x
5 }
6 while (%x > 2) {
7 inc -s %x -1
8 }
9 inc -sz %x 2
10 }

In the following results the line numbers are added after ;. The results are:
* Set %x to 1 ; 1
* Inc %x to 2 ; 2-5
* Inc %x to 3 ; 2-5
* Inc %x to 4 ; 2-5
* Inc %x to 5 ; 2-5
* Inc %x to 4 ; 6-8
* Inc %x to 3 ; 6-8
* Inc %x to 2 ; 6-8
* Inc %x to 4 ; 9 (notice increase with 2)
* Inc %x to 3 ; 9
* Inc %x to 2 ; 9
* Inc %x to 1 ; 9
* Unset %x ; 9 (switch z unsets)

== See Also ==

To decrease a value, you can also use [[dec]].

{{Author|Tovrleaf}}

[[Category:Variables]]

Inc

2005-11-10T14:10:42Z

Saturn: removed line numbers, /inc'ed grammar

This increases the value of %var by value.

/inc [-cszuN] <%var> [value]

Options explained:
uN - increases %var once and [[unset|unsets]] it N seconds later.
z - decreases %var until it reaches zero and then unsets it.
s - displays action in status window
c - increases %var once per second.

If no value is given, default value is 1.

== Example ==

The /inc command is commonly used in [[While_loops|loops]].
var %c = 1
while (%c <= 4) {
; do something
; continue, commands etc..
inc %c
}

Displays %c's values from 1 to 4.
More advanced example, just playing around.

alias exam_inc {
[[set]] -s %x 1
while (%x < 5) {
inc -s %x
}
while (%x > 2) {
inc -s %x -1
}
inc -sz %x 2
}

In the following results the line numbers are added after ;. The results are:
* Set %x to 1 ; 1
* Inc %x to 2 ; 2-5
* Inc %x to 3 ; 2-5
* Inc %x to 4 ; 2-5
* Inc %x to 5 ; 2-5
* Inc %x to 4 ; 6-8
* Inc %x to 3 ; 6-8
* Inc %x to 2 ; 6-8
* Inc %x to 4 ; 9 (notice increase with 2)
* Inc %x to 3 ; 9
* Inc %x to 2 ; 9
* Inc %x to 1 ; 9
* Unset %x ; 9 (switch z unsets)

== See Also ==

To decrease a value, you can also use [[dec]].

{{Author|Tovrleaf}}

[[Category:Variables]]

$chat

2005-11-10T14:05:17Z

Saturn: Reverted edit of Microbe, changed back to last version by Zyberdog

The $chat identifier can be used to return information about your [[DCC|dcc chat]] windows.

$chat(''N''/''nick''[,''N''])

* Specifying ''N'' as 0 returns total number of dcc chat windows.
* If both ''nick'' and ''N'' is given, it will return the information on the ''N''th window for that ''nick''.

'''Property''' '''Meaning'''
ip returns the ip you connected to
status returns the status of the dcc chat connection
logfile returns the full path to the logfile for the dcc chat, or [[$false]] if logging is turned off
stamp returns the timestamp setting, [[$true]] or $false
[[$wid|wid]] returns the window id, numeric value
[[$cid|cid]] returns the connection id it was established under
hwnd returns the hwnd reference

== Example ==

$chat(0) ;returns the total number of open dcc chats
$chat(1) ;returns the nickname of the 1st dcc chat window
$chat(2).ip ;returns the ip address of the 2nd open dcc chat window
$chat(Dana,2).wid ;returns the window number of the second dcc chat window with the nick Dana

== See Also ==

* [[DCC Chat]] - Explains how to initiate a dcc chat session
* [[DCC]] - General information on mIRC's dcc capabilities

[[Category:Window Identifiers]]

$appstate

2005-11-10T14:03:40Z

Saturn: Reverted edit of Microbe, changed back to last version by Zyberdog

Returns the display state of the main mIRC window.

$appstate

* This identifier has no properties or options.
* Will return one of the following states: ''minimized'', ''maximized'', ''normal'', ''hidden'', or ''tray''.

== Example ==
The following example will [[beep]] if mIRC is currently ''minimized'' or in the ''tray''.
on *:[[On_text|TEXT]]:[[$()|$(]]* [[DollarPlus|$+]] [[$me]] $+ *):#:{
;Checking $appstate against a list, seperated by spaces (ascii char 32).
[[If-Then-Else|if]] ([[$istok]](minimized tray,$appstate,32)) {
;Beep because someone mentioned your nick, and mIRC is ''minimized'' or in the ''tray''.
[[beep]]
}
}

== See Also ==

[[$appactive]] which can check the basic state of mIRC.

[[Category:Window Identifiers]]

$appactive

2005-11-10T14:03:02Z

Saturn: Reverted edit of Microbe, changed back to last version by Zyberdog

Returns [[$true]] if mIRC is the active application, otherwise it returns [[$false]].

$appactive

* This identifier has no properties or options.

== Example ==
This example will [[beep]] if someone mentions your nick in a channel, but only if you are currently looking at another application.

on *:[[On_text|TEXT]]:[[$()|$(]]* [[DollarPlus|$+]] [[$me]] $+ *):#:{
;Checking if $appactive returns $false by prefixing it with the ! character.
[[If-Then-Else|if]] (!$appactive) {
;Beep because someone mentioned your nick, and you don't have mIRC in focus!
[[beep]]
}
}

== See Also ==
[[$appstate]] provides more detailed information about what state mIRC is in.

[[Category:Window Identifiers]]

$len

2005-11-10T13:50:11Z

Saturn: small changes

Returns the length of a piece of text, i.e. the number of characters in it.

$len(text)

$len(test string) returns 11.

$len() is a simple, but powerful tool for processing strings.

== Examples ==

This example turns uppercase letters to lowercase and vice-versa.
<br/>$len is used to get the length of the string (the value given to the alias) and loop through its every character.

[[Aliases|alias]] changecase {
[[var]] %i = 1, %str, %c
[[While_loops|while]] (%i <= $len($$1-)) {
%c = [[$mid]]($1-, %i, 1)
[[If-Then-Else|if]] ([[$isupper]](%c)) {
%str = %str [[DollarPlus|$+]] [[$lower]](%c)
}
[[If-Then-Else|else]] {
%str = %str $+ [[$upper]](%c)
}
[[inc]] %i
}
[[return]] %str
}

[[echo]] -a $changecase(Hello)
; returns hELLO
[[Category:Text_and_Number_Identifiers]]

User:Saturn

2005-11-08T21:52:13Z

Saturn:

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

<table border="0">
<tr>
<td>[[Image:Saturn.png]]</td>
<td>
<table border="0">
<tr><td><b>Name</b></td><td>David van Moolenbroek</td></tr>
<tr><td><b>Age</b></td><td>22</td></tr>
<tr><td><b>Country</b></td><td>The Netherlands</td></tr>
<tr valign="top" height="40"><td><b>Access level</b></td><td>quakenet staff</td></tr>

<tr><td><b>Words of wisdom</b></td><td>The eyes of truth are always watching you.</td></tr>
</table>
</td>
</tr>
</table>
[[Category:Members]][[Category:Quakenet_Staff]]

File:Saturn.png

2005-11-08T21:51:35Z

Saturn: Saturn's avatar

Saturn's avatar

User:Saturn

2005-11-08T21:47:04Z

Saturn:

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

<table border="0">
<tr>
<td>[[Image:Saturn.jpg]]</td>
<td>
<table border="0">
<tr><td><b>Name</b></td><td>David van Moolenbroek</td></tr>
<tr><td><b>Age</b></td><td>22</td></tr>
<tr><td><b>Country</b></td><td>The Netherlands</td></tr>
<tr valign="top" height="40"><td><b>Access level</b></td><td>quakenet staff</td></tr>

<tr><td><b>Words of wisdom</b></td><td>The eyes of truth are always watching you.</td></tr>
</table>
</td>
</tr>
</table>
[[Category:Members]][[Category:Quakenet_Staff]]