Welkom.
Ik begin mijn guide met het overlopen van de syntax van functies in mIRC, zoals ze gebruikt worden en uitgelegd staan in de officiële manual.
Er zijn 2 soorten commando's: Degene die beginnen met een / en degene die beginnen met een $.
∼ /commando: Voert het commando met naam 'commando' uit. De '/' mag in de script editor worden weggelaten. Dit doe ik ook, omdat zowat alle scripters (waaronder ikzelf) het ordelijker vinden. Dit zijn de gewone 'Commands'.
∼ $commando: Roept het commando met naam 'commando' aan en keert terug naar waar hij vandaan komt. Deze worden 'Identifiers' genoemd.
∼ Dingen tussen < > zijn verplichte onderdelen. Daar MOET altijd iets staan.
∼ Dingen tussen [ ] zijn optioneel. Deze kun je dus instellen, maar dat is niet verplicht.
∼ Ik hou me ook aan vaste kleuren. Standaard zijn scripts
rood, maar bij een vergelijking tussen scripts kan dit afwijken naar
oranje. Alle syntaxuitleg is in het
groen. Tot slot zijn de dingen die je moet intypen waar je praat
blauw gekleurd, en wat daar dan uitkomt is
paars.
Aangezien leren scripten een werk van lange duur is, zul je hier meerdere keren komen kijken. Daarom zal een inhoudsopgave waarschijnlijk wel handig zijn. Hier komt ie:
Remote
Het belangrijkste onderdeel van de mIRC-script editor is de Remote.
In je Remote kun je je scripts laten reageren op triggers. Ik overloop even de belangrijkste:
on TEXT
on <level>:TEXT:<matchtext>:<*><?><#[,#]>:<commands>
∼ <level>: Deze heb je ongeveer nooit nodig. Daarom kun je hier zowat altijd een * zetten.
∼ TEXT: Dit wil zeggen dat het om tekst gaat. Wat mensen tegen je zeggen dus.
∼ <matchtext>: Die definieert hetgeen wat er gezegd wordt. Hier kunnen * en ? als wildcards gebruikt worden. Een wildcard is iets wat een tekst niet specifiek geeft, maar verschillende dingen kan matchen. * matcht meerdere tekens, ? slechts 1. Zo zal k*k dus koek en kakkerlak matchen, terwijl r?t wel rat of rot matcht, maar niet roet.
∼ <*><?><#[,#]>: Je hebt elke keer slechts één ervan nodig. # wil zeggen dat hij matcht in channels. Hier kun je ook channels specifiëren. Indien er meerdere zijn, zet je er een komma tussen. Als je hier een ? zet, wil dat zeggen dat je wil dat het event triggert op een tekst in private. Een * matcht altijd, dus zowel in een channel als in een pm.
∼ <commands>: Hier zet je wat het script moet doen.
Bijvoorbeeld:
on *:TEXT:!calc*:#:msg $chan $2- = $calc($2-)
Deze triggert op een tekst die begint met !calc. Maar ik vrees dat ik hier wat meer uitleg bij moet geven.
∼ msg is de afkorting van 'message'. Dit betekent dat je een bericht stuurt.
∼ $chan geeft het channel waarin de tekst gezegd wordt. Dit is zodat je het antwoord natuurlijk naar de goede plaats stuurt.
∼ $2-. Dit wordt moeilijker.
Een tekst wordt standaard verdeeld in tokens volgens spatie. Daarover later meer. $1 wil dan het eerste woord zeggen, $2 het tweede woord etc. Met een - erachter, bedoel je 'alles vanaf het ..e woord'. Met $0 wordt het aantal woorden bedoeld.
Stel nu dus dat deze tekst getriggerd heeft op '!calculate 2 + 3'. Ja, dit kan, want hij begint met !calc. $1 zal !calculate zijn, $4 is 3; $0 is 4 en $2- is 2 + 3.
∼ = is gewoon letterlijk een =
∼ $calc($2-). De betekenis van $2- hebben we daarnet gezien. Als je er nu $calc( ) rondom zet, zal mIRC wat ertussen staat uitrekenen.
on INPUT
on :INPUT:<*#?=!@>:
∼ INPUT: Dit is wat je ZELF typt. Hij matcht niet op wat anderen zeggen, en TEXT matcht NIET op wat jij zelf zegt!
∼ *, # en ? hebben we al gezien. @ is een scherm dat je zelf maakt met /window @naam-hier. = wil een DCC-chat zeggen en ! file server. Deze gaan we echter niet gebruiken.
Wat opvalt is dat we bij on INPUT geen matchtext hebben. Hoe moeten we dat dan doen?
Je weet dat je je tekst kunt bekijken met $1, $2 enzovoort. Deze kunnen we dan weer met een if evalueren. Ik demonstreer weer met een voorbeeldje met de calc:
on *:INPUT:*:{
if ($1 == !calc) {
describe $active berekent dat $2- gelijk is aan $calc($2-) $+ !
}
}
Wat je waarschijnlijk meteen opvalt, is het gebruik van { }. Dit is verplicht als je je script over meerdere regels wil spreiden. Ik prefereer dit zelfs altijd te doen, gewoon omdat het overzichtelijker is.
De if slaan we even over en we kijken naar wat ertussen staat.
∼ describe: Dat is de scriptvorm van /me. Er moet wel nog een channel of een nick achter.
∼ $active: Wordt vervangen door het actieve venster, of dat nu een channel of een nick is. Die is dus nodig om de /describe te laten werken.
∼ $+: Omdat je geen tekst vlak tegen code mag zetten, kun je niet $calc($2-)! doen. Het uitroepteken zou gewoon wegvallen. En als je $calc($2-) ! doet, staat er een spatie tussen. De oplossing hiervoor is het gebruik van $+. Die haalt alle spaties weg die op die plaats staan. Dus a $+ b geeft ab.
∼ En nu if ($1 == !calc): if betekent 'als'. Dit is dan ook de betekenis. Als "$1 == !calc", voer dan het script uit, anders niet. Meer info over if-structuren vind je hier. Als je nog geen ervaring hebt met een andere script- of programmeertaal, is het sterk aangeraden om deze al te lezen voordat je verdergaat.
Als je dit script gaat uitvoeren, zul je echter zien dat je éérst het antwoord geeft, en dat dán pas je input komt. Dit is omdat het script wordt uitgevoerd voordat de eigenlijke tekst verzonden wordt (om eventuele aanpassingen daaraan te kunnen doen). Dit is simpel op te lossen met een timer. Het uiteindelijke script wordt dus:
on *:INPUT:*:{
if ($1 == !calc) {
.timer 1 0 describe $active berekent dat $2- gelijk is aan $calc($2-) $+ !
}
}
Meer info over timers vind je
hier. Het . ervoor is kort genoeg om hier ter plekke uit te leggen. Een punt voor een functie verbergt deze. Zonder dat punt zou je dit elke keer op je scherm gespamd krijgen:
* Timer 1 activated
* Timer 1 halted
Het punt voorkomt dat.
on KICK
on :KICK:<#[,#]>:<commands>
Ondertussen begrijp je wel alles, dus ik stap meteen over naar het voorbeeldje.
on *:KICK:#:{
if ($knick == $me) {
echo 4 -a $nick heeft me uit $chan getrapt! Wat een stouterik!
}
elseif ($knick == $nick) {
echo 4 -a Haha! $nick heeft zichzelf uit $chan gegooid!
}
else {
echo 4 -a $nick heeft $knick uit $chan getrapt, dat zal hem leren!
}
}
Even een korte uitleg:
∼ $nick: Dit is altijd de naam van de persoon die de handeling uitvoert. In dit geval dus degene die de kick geeft. Bij een on TEXT-event zal het dus de persoon zijn die de tekst gezegd heeft enzovoort.
∼ $knick: De naam van de persoon die gekickt is. Als '$knick == $me', wil dat dus zeggen dat jij dat bent.
∼ $me: Dat is - je raadt het nooit - je eigen nick op de server in kwestie.
∼ echo 4 -a: Een echo is een tekst die alleen bij jezelf op het scherm verschijnt. De 4 wijst op de kleur (rood) en de -a is iets wat met een 'switch' noemt. Switches worden bijna altijd aangegeven met een - ervoor. /echo heeft er een dikke 15, maar die ga ik niet allemaal uitleggen, dat zoek je maar op in de manual als je het nodig hebt. De enige die vaak gebruikt wordt is -a. Dat wil zeggen dat de echo in het actieve scherm gebeurt, zelfs als de trigger op een andere server is! Indien -a niet is opgegeven, moet je een naam/channel specifiëren, of hij wordt in het statusscherm ge-echoot.
∼ elseif/else: Deze twee worden vaak in combinatie gebruikt met if. 'Else' betekent 'anders'. Hij gaat alleen door als de if ervoor niet matcht. Bij een elseif kun je nog een voorwaarde eraan hangen. In dit geval kijkt hij dus eerst of jij het bent die gekickt is, anders kijkt hij of de kicker zichzelf gekickt heeft, en als ook dat niet het geval is, spuwt hij de laatste tekst uit. Als jij gekickt bent, zullen de andere regels gewoon overgeslagen worden. Dus zelfs als een andere elseif zou kunnen matchen (wat hier niet het geval is), dan doet hij dat niet. Omdat de 'anders' erin zit.
on ACTION
on <level>:TEXT:<matchtext>:<*><?><#[,#]>:<commands>
De syntax is weer hetzelfde zoals altijd, en hoeft dus geen extra uitleg. Maar wat doet het? Een on ACTION-script matcht op een /me-tekst. Dus als je dit in je Remote zet:
on *:ACTION:*huggles Tim*:#:{ describe $chan huggles $nick }
Dan matcht die als iemand een /me doet met de tekst 'huggles Tim' erin. Dit script zul je ondertussen al wel geweldig simpel vinden, maar bij de /describe is de kans groot dat je even raar gaat kijken.
∼ /describe: Dit is hetzelfde als een /me-command, met als verschil dat je die niet in je script editor kunt gebruiken. Daar moet je het met /describe -de plek waar je het wil- doen. Hier even de vergelijking:
/describe $active vindt mIRC een geweldig chatprogramma!
is hetzelfde als:
/me vindt mIRC een geweldig chatprogramma!
Voor degenen die het nog niet zouden weten, dit is de output:
* Tim vindt mIRC een geweldig chatprogramma!
Maar zoals ik dus al gezegd heb, kan die tweede hier niet gebruikt worden.
If-structuren
if-structuren zijn heel belangrijk in alle script- en programmeertalen. Ze voeren code enkel uit als aan een bepaalde voorwaarde is voldaan. In aliases wordt een tweede vorm uitgelegd, dus ik dump de basis hier nog tussen. De meeste if-structuren voldoen aan deze syntax:
if (v1 operator v2) { }
v1 en v2 zijn twee dingen die je wil vergelijken. In een script kunnen ze aangeroepen worden door $v1 en $v2. De operator kan vanalles zijn. Hier een kort lijstje van de belangrijkste:
|
==
|
is gelijk aan
|
|
===
|
is gelijk aan (hoofdlettergevoelig)
|
|
!=
|
is niet gelijk aan
|
|
<
|
kleiner dan; <= voor kleiner dan OF gelijk aan
|
|
>
|
groter dan; >= voor groter dan OF gelijk aan
|
|
isin
|
zit in (letterlijk, bv "er" zit in "boer"); isincs voor hoofdlettergevoelig
|
|
//
|
is een deler van
|
|
is geen deler van
|
|
iswm
|
is een wildcard voor
|
|
isnum [n1-n2]
|
is een nummer [tussen n1 en n2]
|
|
isalpha [lijst-van-letters]
|
is een letter [in de opgegeven lijst]
|
|
ison
|
zit in (qua channel)
|
|
isop/ishop/isvoice
|
is operator (+o)/is half-op (+h)/is voice (+v) in
|
ALLE commando's kunnen geïnverteerd worden door een ! ervoor te zetten. "if ($me !isop $chan)" matcht als jij GEEN +o hebt in het channel.
Voor een completere lijst, zie de mIRC-manual (/help [if then else])
Nog één laatste nota bij if-structuren is dat je meerdere voorwaarden kan stellen in 1 if. Je kunt 'en' of 'of' gebruiken. De tekens hiervoor zijn respectievelijk '&&' en '||' (zonder ' ' natuurlijk). Dus deze twee zijn idem:
if ($1 == Hoi) {
if ($2 == $me) {
msg $chan Jij ook een goedemorgen!
}
}
if ($1 == Hoi) && ($2 == $me) {
msg $chan Jij ook een goedemorgen!
}
En ook deze twee zijn hetzelfde:
if ($1- == Hoi $me) {
msg $chan Hoi!
}
if ($1- == Hallo $me) {
msg $chan Hoi!
}
if ($1- == Hoi $me) || ($1- == Hallo $me) {
msg $chan Hoi!
}
Nu we dat kunnen, zijn we volledig klaar voor het volgende hoofdstuk.
Aliases
Het tweede belangrijke onderdeel van scripten is het gebruik van aliases. Een alias is een script waarnaar je in een ander script kunt verwijzen, of die je als een /-of $-commando kunt gebruiken. Dit is bijvoorbeeld handig als je vaak hetzelfde nodig hebt, maar bij een andere trigger: dan kun je gewoon verwijzen naar de alias, en hoef je je script maar één keer uit te typen.
De syntax van een alias in het alias-tabblad is simpel. Bovendien is het overal hetzelfde. Het is gewoon dit:
Aliasnaam { }
Met tussen de haakjes wat hij moet doen. Dit werkt hetzelfde als in een remote. Ook van daaruit kun je er één maken trouwens, iets wat ik over het algemeen prefereer boven het echte aliasscherm. Daar moet je het zo doen:
alias Aliasnaam { }
Alle verdere voorbeelden zullen op deze manier getypt worden, en moeten dus in het Remotescherm geplaatst worden om te werken. Bovendien zal door de alias ervoor duidelijk worden dat het een alias is. Hier een simpel scriptje, waar de verschillende mogelijkheden worden uitgelegd.
alias dubbel { return Het dubbel van $1 is $calc(2*$1) }
Hier zit één nieuw dingetje in: /return. Die doet wat het zegt: hij keert terug naar de plaats waar hij is aangeroepen. Als er iets achter return staat, wordt die waarde meegenomen. Nu zijn er drie mogelijkheden:
/dubbel
Deze zal geen effect hebben.
/echo -a $dubbel(3)
Je zal nu letterlijk "$dubbel(3)" als echo krijgen.
//echo -a $dubbel(3)
Je krijgt nu "Het dubbel van 3 is 6" als echo. De reden hiervoor is dat de / een evaluatie is. "/echo" evalueert de echo, en zal dan ook echoën. Wat erachter staat, wordt echter als letterlijk aangenomen. Door "//echo" te gebruiken, zal ook de tekst erachter geëvalueerd worden, en roept die dus de alias aan. Die geeft "Het dubbel van 3 is 6" terug, en dat zal er dan ook ge-echoot worden.
Voordat ik het volgende voorbeeld geef, gaan we eerst nog een tussenstapje maken langs de variabelen.
Een variabele is iets wat je mIRC kan onthouden. Ofwel totdat je ze handmatig unset, ofwel tot het einde van een script. Het verschil is of je /set of /var gebruikt om ze te creëren. Ik zet ze langs elkaar om duidelijkheid te scheppen.
Wat je hiervoor nog moet weten, is dat je meerdere dingen op 1 regel kunt schrijven door het gebruik van een |. Deze commando's worden na elkaar uitgevoerd. Voordat we beginnen nog even een voorbeeldje om het duidelijk te maken:
//echo -a $dubbel(3) | echo -a $dubbel(5) | echo -a $dubbel(7)
Dit zal drie keer echo'en, in de volgorde die je hebt opgegeven. Voor de ietwat minder begaafden, dit wordt de output van mIRC:
Het dubbel van 3 is 6
Het dubbel van 5 is 10
Het dubbel van 7 is 14
Nu we dat weten, kunnen we aan de uitleg over variabelen beginnen. Kijk ernaar dat omwille van de | de regels met een dubbele slash moeten beginnen.
|
/set
|
/var
|
//set %testvar Hoi | echo -a De variabele heeft als waarde: %testvar | unset %testvar
|
//var %testvar Hoi | echo -a De variabele heeft als waarde: %testvar
|
|
Merk op dat de variabele die met /var geset is geen unset nodig heeft
|
/set %testvar Hoi
//echo -a De variabele heeft als waarde: %testvar
/unset %testvar
|
/var %testvar Hoi
//echo -a De variabele heeft als waarde: %testvar
|
|
De tweede zal geen waarde meer hebben. De /var heeft ervoor gezorgd dat de variabele niet meer bestaat zo gauw hij de regel afgehandeld heeft. Let er ook weer op dat de echo een dubbele slash heeft, omdat hij anders de variabele niet evalueert.
|
Met die kennis over variabelen, hier het volgende script, dat laat zien hoe je gewone events met een trigger en aliases kunt combineren. Er zijn weer enkele kleine nieuwigheidjes, die nadien verklaard worden.
on *:TEXT:!faculteit*:*:{
;Regels die met een ; beginnen zijn commentaarregels
;Ze worden tijdens het uitvoeren van het script genegeerd
;Ze worden vooral gebruikt bij lange scripts, om meer uitleg bij een stukje te schrijven.
msg $iif($chan,$chan,$nick) $1 $+ ! = $faculteit($2)
}
alias faculteit {
var %i 1,%f 1
while (%i <= $1) {
%f = %f * %i
inc %i
}
return %f
}
Voordat we aan de alias gaan beginnen, die er nu nog veel te moeilijk uitziet, gaan we eerst de $iif eens bekijken. Een $iif is een korte vorm van een if/else-structuur. Ze worden gescheiden met een komma:
$iif(ALS,DAN,ANDERS)
$iif(ALS,DAN,$iif(ANDERS ALS,DAN,ANDERS))
Als 'ALS' matcht, zal de eerste 'DAN' worden uitgevoerd. Indien niet, zal de tweede $iif geëvalueerd worden. Als 'ANDERS ALS' matcht, die dezelfde waarde heeft als een elseif, zal de tweede 'DAN' worden uitgevoerd. Als ook die faalt, wordt 'ANDERS', die zoveel is als een else, uitgevoerd.
Nu kun je je best even recht zetten, want we gaan aan de alias faculteit beginnen. Het lijkt me het beste om eerst een korte uitleg te geven wat faculteit precies is. Een faculteit van een getal is het product van dat getal met alle vorige getallen tot en met 1.
3! = 3 * 2 * 1 = 6
Nu we dat weten, gaan we de alias stapje voor stapje overlopen.
∼ var %i 1, %f 1: We creëren de variabelen %i en %f en geven ze allebei de waarde 1. Je kunt ze ook een andere naam geven. Je kunt met een /var zoveel variabelen als je wil op 1 regel zetten, maar dit gaat NIET met een /set!
∼ while (%i <= $1) { : While is Engels voor 'terwijl, zolang als'. Zolang de variabele %i kleiner of gelijk aan $1 is, blijft alles wat er tussen het begin- en eindhaakje van while staat herhaald worden.
We bekijken nu wat $1 is. We hebben de alias aangeroepen vanuit ons on TEXT-event met $faculteit($2). De tekst die je tussen de haakjes meegeeft, wordt weer als tokens bekeken, maar deze keer gescheiden met komma's ipv. met spaties. Wat bij je trigger dus $2 was, wordt nu $1.
∼ %f = %f * %i : We kunnen variabelen ook waardes geven door een = te gebruiken. Normaal gezien wordt dat als een /set bekeken, met andere woorden, je variabele blijft staan nadat je script gedaan is. Maar omdat we de variabele éérst gemaakt hebben met /var, zal dat toch niet het geval zijn.
Je zou misschien verwachten dat de waarde van %f nu letterlijk "%f * %i" is, maar dat is niet het geval. Niet alleen worden %f en %i geëvalueerd, ook * wordt als een echt maalteken bekeken. Je kunt dus echte berekeningen maken met variabelen, maar SLECHTS ÉÉN per keer! Dingen als "%f = %f * (%i - 1)" werken NIET. Dan moet je er $calc rond zetten. De berekeningen die ondersteund worden voor variabelen zijn optellen (+), aftrekken (-), vermenigvuldigen (*), delen (/), machtsverheffing (^) en modulus (%).
∼ inc %i : Deze zorgt ervoor dat de waarde van %i 1 hoger wordt gedaan. Als je dit wil veranderen, bv naar een verhoging met 2, moet je 'inc %i 2' typen.
∼ } : het eindhaakje van de while-loop. Tot hier blijft de herhaling gaan.
∼ return %f : De waarde van %f wordt naar het beginpunt teruggestuurd, zodat je trigger kan eindigen.
Om de werking van dit script duidelijk te maken, overloop ik het eventjes met input 3. Wat doet het script als iemand '!faculteit 3' doet?
- De commentaarregels worden overgeslagen
- Hij wil het bericht sturen, maar evalueert eerst alles wat erin staat.
- $iif($chan,$chan,$nick): Hij kijkt of het in een channel gezegd is (anders zal $channel geen waarde hebben, en zal de if niet slagen). Indien ja, stuurt hij de tekst naar het channel, anders naar de nick (want dat wil immers zeggen dat het in private gezegd is).
- $2 wordt 3.
- Door de $+ wordt ! er vlak achter gezet.
- Hij ziet dat er een alias in aangeroepen wordt. Hij voert dus eerst de alias uit.
- De variabelen %i en %f krijgen waarde 1
- %i = 1, $1 = 3. %i < $1, dus de whileloop wordt uitgevoerd.
- %f krijgt de waarde %f * %i = 1 * 1 = 1
- %i wordt verhoogd naar 2
- De whileloop wordt opnieuw gestart. %i = 2 en $1 is 3, dus de loop wordt nogmaals uitgevoerd.
- %f krijgt de waarde %f * %i = 1 * 2 = 2
- %i wordt verhoogd naar 3
- De whileloop wordt opnieuw gestart. %i = 3 en $1 is 3. %i = $1, maar dat mag, dus de loop wordt nog een keer uitgevoerd.
- %f krijgt de waarde %f * %i = 2 * 3 = 6
- %i wordt verhoogd naar 4
- De whileloop wordt opnieuw gestart. %i = 4 en $1 is 3. %i is dus niet meer kleiner of gelijk aan 4, en de loop wordt afgebroken.
- Het script gaat verder naar de regel na de loop. Dit is 'return %f'. Hij keert terug naar het on TEXT-event, en zet waarde 6 op de plaats van $faculteit($2).
- Het bericht is nu klaar, er staat gewoon een platte tekst. "3! = 6". Hij stuurt dit naar het channel waar of de persoon wie het gezegd heeft.
Tokens
Dit is geen apart onderdeel van mIRC: het hoort zowel bij Remote als Aliases, maar ze zijn zo belangrijk, dat ik ze uitdiep. Na het hele theoriehoofdstukje, zal ik alles nogmaals verduidelijken met scripts waarin ik alles gebruik.
Zoals ik eerder al gezegd heb, wordt inkomende tekst standaard in tokens verdeeld volgens spaties. Dit kun je ook handmatig doen, volgens welk teken je maar wil. Dat gebeurt met /tokenize.
//tokenize 32 Hoi, ik ben Tim! | echo -a $1 | echo -a $2-
Hier zal dit uitkomen:
Hoi,
ik ben Tim!
Dit komt omdat ik je nu handmatig de tekst "Hoi, ik ben Tim!" volgens spaties in tokens hebt verdeeld. Dat doet de 32. 32 is het asciinummer van een spatie. Als je niet weet wat asciinummers zijn, kijk
hier dan even.
Nu we de opbouw van tokens kennen, kunnen we ermee gaan werken. Ik overloop de belangrijkste functies, voor meer mogelijkheden, verwijs ik je door naar de mIRC-manual.
$gettok
We hebben daarnet gezien dat je dit kunt doen:
//tokenize 33 Hoi! Ik ben Tim! Hoe heet jij? | echo -a $2
Dat is exact hetzelfde als dit:
//echo -a $gettok(Hoi! Ik ben Tim! Hoe heet jij?,2,33)
Voor de eerste komma staat de tekst waarover het gaat. Let op dat hier GEEN komma's mogen staan. Als je er een komma wil zetten, moet je gebruik maken van $chr(44), het omgekeerde van $asc.
Na de eerste komma staat de hoeveelste token je wil gebruiken, in dit geval de tweede.
Het laatste stukje wil zeggen dat je volgens het teken met asciinummer 33 de tokens wil indelen, dat is een uitroepteken.
Het handige van $gettok tegenover /tokenize is niet alleen dat het korter is, maar ook dat je negatieve cijfers kunt gebruiken. Hij begint dan vanaf rechts te tellen.
//echo -a $gettok(Hoi! Ik ben Tim! Hoe heet jij?,-3,33)
Hoi
Merk ook op dat het uitroepteken in geen enkele token meer zit. Het is de splitser, dus hij hoort nergens bij.
$numtok
Geeft het aantal tokens in de tekst. Bij een /tokenize is dat $0.
//echo -a $numtok(Hoi! Ik ben Tim! Hoe heet jij?,33)
3
Als je nu nog weet dat het teken met asciinummer 33
! is, lijkt me dit voldoende uitleg.
$istok
Geeft $true als de token bestaat, anders geeft hij $false. Ook hier maak ik me er vanaf met twee simpele voorbeeldjes. De syntax kun je zelf wel verzinnen, lijkt me, het is dezelfde als $gettok.
//echo -a $istok(Hoi! Ik ben Tim! Hoe heet jij?,Hoi,33)
$true
//echo -a $istok(Hoi! Ik ben Tim! Hoe heet jij?,Ik ben Tim,33)
$false
$false? Ja. Want de tokens zijn heel specifiek. De token "Ik ben Tim" bestaat niet, de token " Ik ben Tim" (met een spatie vooraan!) wel. Dat is het verschil.
$addtok
Dit voegt een token toe aan de tekst. Ook hier weer heb je dezelfde syntax als $gettok. Het handige hieraan is dat de token slechts toegevoegd wordt als hij nog niet bestaat. Hier komen de voorbeeldjes weer:
//echo -a $addtok(Ik voeg hier een woord aan,toe,32)
Ik voeg hier een woord aan toe
//echo -a $addtok(Hier niet want in zit er al,in,32)
Hier niet want in zit er al
//echo -a $addtok(Hier wel want 'in' zit er door de aanhalingstekens nog niet,in,32)
Hier wel want 'in' zit er door de aanhalingstekens nog niet in
Timers
Timers zijn er om commando's uit te stellen. Zoals wel vaker beginnen we met de syntax.
/timer[N/name] [-cdeomhipr] [time] <repetitions> <interval> <command>
Je kunt een timer starten gewoon met /timer. Deze krijgt dan standaard een nummer toegewezen. Als je de timer later nog nodig hebt, kun je hem echter beter een naam geven. Dat doe je door gewoon de naam rechtstreeks aan /timer te plakken.
De switches zijn niet zo interessant. De enige die dat eventueel wel is, is -o, die ervoor zorgt dat je timer ook bij een eventuele disconnect blijft doorlopen (standaard gaan dan alle timers uit!).
Daarna kun je eventueel een tijd instellen. Dat is het moment waarop de timer eigenlijk pas moet beginnen. In plaats van uit te tellen hoeveel seconden het nog zijn tot 17:38, kun je gewoon de tijd instellen.
Repetitions, dat is het aantal keer dat de timer moet lopen. Zet je hier 3, dan zal hij nadat hij klaar is, opnieuw beginnen, en daarna nog eens.
Bij interval moet je zeggen hoelang de timer moet duren. Deze tijd is in seconden. Zet je hier dus 30, dan zal het command een halve minuut later uitgevoerd worden.
En nu zijn we eindelijk bij wat de timer echt moet doen. Hier kun je heel veel neerzetten, maar als het iets is wat ietwat ingewikkeld is, kun je beter een alias schrijven en die aanroepen. Bovendien is de evaluatie van timers soms vreemd (Doe maar eens '/timer 1 10 echo -a $time', dan zul je zien dat hij de tijd echoot op het moment dat de timer startte), dus vaak is het sowieso al een goed idee. Als je echter al wat meer ervaring hebt, kun je het ook wel op de gewone manier doen.
Kijken we nog even naar het voorbeeldje bij ons
on INPUT-scriptje:
.timer 1 0 describe $active berekent dat $2- gelijk is aan $calc($2-) $+ !
De timer start onmiddellijk, aangezien er geen tijd is aangegeven. Hij loopt 1x, met een tussentijd van 0 seconden. Nu zou je denken dat dat nutteloos is, maar timers van 0 seconden zijn eigenlijk iets speciaal. Ze stoppen pas als het event dat ze getriggerd heeft afgelopen is. Dus hier, zo gauw je on INPUT-script gedaan is, en de vraag ook werkelijk verstuurd is.
Ascii
Als je wil weten welk asciinummer een teken heeft, kun je $asc gebruiken. Dat gaat zo:
//echo -a $asc(!)
33
//echo -a $asc(.)
46
Sommige tekens geven echter een foutboodschap. Dat heeft te maken met mIRC-syntax. Daarom stel ik voor om dit kleine scriptje te laden, dat je het asciinummer geeft met /asc -teken-:
alias asc { echo -a $!asc( $+ $1 $+ ) = $asc($1) }
Het enige teken dat je op deze manier nog steeds niet kunt conroleren is de spatie. Maar die heb je zo vaak nodig, dat je binnen de kortste keren weet dat dat 32 is.
Oplettende lezers hebben trouwens waarschijnlijk wel gemerkt dat ik $!asc gebruik de eerste keer. De bedoeling daarvan is om evaluatie tegen te gaan. Meer info daarover vind je hieronder bij het hoofdstuk over
evaluaties.
Een andere manier om echt van élk teken (behalve '$null', maar die is 0) de asciiwaarde te kunnen zoeken, is deze:
//echo -a $asc($$?)
De $? zorgt ervoor dat er een popup komt die je een input vraagt. De dubbele $$ zorgt dat het script alleen wordt uitgevoerd als er ook echt een input is. (Als je niks ingeeft of op cancel drukt, krijg je dus geen foutboodschap, maar wordt het script niet uitgevoerd.
Evaluaties
Een regel in je script editor kun je eigenlijk beschouwen als eentje met // voor. Hij doet dus //echo, waardoor gewoon $asc (zoals de tweede doet) zou evalueren. Pas bij een tweede evaluatie zou deze werkzaam zijn. De uitroeptekens kun je blijven opbouwen trouwens, naar bijvoorbeeld $!!!asc(.), die pas bij een vierde evaluatie 46 echoot.
Dingen evalueren in mIRC-script kun je op twee manieren. Ofwel door evaluatiehaken [ ] er rond te zetten, ofwel door de functie $eval. Merk op dat in je script editor één evaluatie slechts zelden nodig is, aangezien die automatisch gebeurt (dit wordt enkel gebruikt als iets per se vóór iets anders moet evalueren). Om terug te komen op het voorbeeldje van daarnet:
//echo -a $!!asc(.)
$!asc(.)
//echo -a [ $!!asc(.) ] of //echo -a $eval($!!asc(.))
$!asc(.)
Zoals ik dus zei: één keer evalueren gebeurt automatisch, dus dit geeft exact hetzelfde als zonder [ ] of $eval.
//echo -a [ [ $!!asc(.) ] ] of //echo -a $eval($!!asc(.),2)
$asc(.)
Indien je eval wil gebruiken voor meerdere evaluaties, zet je een getal in '$2'. Denk eraan dat die bij aliases (want een functie is eigenlijk een niet-editbare alias) op deze manier aangeroepen worden.
//echo -a [ [ [ $!!asc(.) ] ] ] of //echo -a $eval($!!asc(.),3)
46
Na drie evaluaties zijn we eindelijk bij de echte asciiwaarde van het punt. Uitroeptekens worden als evaluatieontwijker gebruikt om functies letterlijk weer te geven, zoals ik deed in /asc.
Voorbeeldscriptjes
Jaja, het leuke gedeelte ^^
Channels negeren
Voor het eerste voorbeeldje gaan we ons een beetje inleven. Stel je voor dat je hebt gezwoegd om een goed script af te krijgen, maar in de channels #We-Are-Lame, #N00b4l1f3 en #scripthaters appreciëren ze het niet, en daarom wil je ook niet dat zij kunnen profiteren van je harde werk. Nu kun je dit doen:
on *:TEXT:!trigger:#:{
if ($chan != #We-Are-Lame) && ($chan != #N00b4l1f3) && ($chan != #scripthaters) { script }
}
Je ziet natuurlijk meteen dat dit geen optie is als je veel channels nodig hebt. Je volgende poging is dan zoiets::
on *:TEXT:!trigger:#:{
if ($chan !isin #We-Are-Lame #N00b4l1f3 #scripthaters) { script }
}
Maar wat als je ook in het channel #script zit en je je script daar wél wil laten draaien? #script zit in die lijst, namelijk hier: "#We-Are-Lame #N00b4l1f3
#scripthaters"
Dan denk je terug aan wat ik je nu zeg, en gebruik je tokens.
on *:TEXT:!trigger:#:{
if (!$istok(#We-Are-Lame #N00b4l1f3 #scripthaters,$chan,32)) { script }
}
Deze zal #script wel doorlaten, want de letterlijke token #script bestaat niet.
Achterstevoren praten
Dit script geef ik met een 'slechtere' versie erbij, in een commentaarregel. Daar staan wat extra dingetjes die vaak gebruikt worden en nog uitleg nodig hebben, en dan kun je eens vergelijken.
alias achterstevoren {
var %tekstlen = $len($1-)
while (%tekstlen) {
;var %achterstevoren = %achterstevoren $+ $right($left($replace($1-,$chr(32),$chr(160)),%tekstlen),1)
var %achterstevoren = %achterstevoren $+ $mid($replace($1-,$chr(32),$chr(160)),%tekstlen,1)
dec %tekstlen
}
return $replace(%achterstevoren,$chr(160),$chr(32))
}
∼ Eerst zetten we de waarde van de variabele %tekstlen naar $len($1-). Dit is de totale lengte van de input. $len() geeft namelijk de lengte van iets, en $1- is de volledige zin.
∼ De whileloop blijft lopen zolang %tekstlen bestaat. Dit is zolang %tekstlen niet als waarde '$false', '$null' '0' of '' (leeg) heeft. Verder in de whileloop zie je dec %tekstlen staan. Dit is het omgekeerde van /inc: hij vermindert de waarde met 1. Uiteindelijk wordt hij 0, en op dat moment zal de whileloop onderbroken worden.
∼ Eerst de eerste regel. We beginnen met het gemakkelijkste: $replace. Iedereen met een basis Engels weet dat dat 'vervangen' is. Hier is dat nodig om de spatie ($chr(32)) te vervangen door $chr(160), zodat de $+ die niet weghaalt. $chr(160) wordt soms wel 'een valse spatie' genoemd. De syntax is eenvoudig:
$replace(string,substring,newstring,newsubsring...)
Als eerste zet je de tekst waarin je dingen wil vervangen. Substring is het ding wat je wil vervangen en newstring het ding waarin je het wil vervangen. Dit kun je de hele tijd blijven doen. Even een klein voorbeeldje om het te verduidelijken.
//echo -a $replace(abcba,a,1,c,3)
1b3b1
Alle a's zijn vervangen door 1, alle c's (dat is er maar één) zijn vervangen door 3. Aan de b is niet geraakt.
∼ $left/$right geeft het aangegeven aantal tekens vanaf links/rechts. Negatieve waarden geven alles behalve de laatste. Zoals altijd zijn voorbeelden weer een veel betere uitleg.
//echo -a $left(hallo,3)
hal
//echo -a $left(hallo,-1)
hall
//echo -a $right(hallo,3)
llo
//echo -a $right(hallo,-3)
lo
∼ In de andere regel zie je als enige verschil dat de combinatie van $left en $right vervangen is door $mid. $mid werkt zo:
$mid(string,positie,aantal tekens)
Hij begint in een gegeven string op de positie gegeven door $2, en leest dan het aantal tekens uit dat in $3 gegeven is. (denk eraan: in een alias worden tokens gescheiden door een komma, dus $2 is 'positie' en $3 is 'aantal tekens'!).
Nog een laatste voorbeeldje om het af te leren:
//echo -a $mid(tafelvoetbal,3,7)
felvoet
//echo -a $mid(tafelvoetbal,-8,7)
lvoetba
Bij de tweede begint hij de positie vanaf rechts te tellen. Het achtste teken is dan de eerste l. Vanaf daar gaat hij 7 tekens verder.
Neem je het aantal tekens negatief, dan begint hij aan het startpunt, tot op dat aantal tekens van het einde.
//echo -a $mid(tafelvoetbal,4,-4)
elvoe
//echo -a $mid(tafelvoetbal,-5,-4)
e
Het script zet dus, bij beide methoden, eerst het laatste teken in %achterstevoren. Dan voegt hij daar het teken ervoor aan toe, enzovoor, tot je aan het begin van je string zit. Dan heeft %tekstlen waarde 0, en gaat hij over naar de return. Daar moet weer $replace(%achterstevoren,$chr(160),$chr(32)) staan, zodat hij de valse spaties weer vervangt naar echte.
Opdrachten
Als jullie alles in deze guide goed snappen, zouden jullie deze simpele opdrachtjes tot een goed einde moeten kunnen brengen.
∼ $fibonacci: Maak een alias die volgens de syntax $fibonacci(n) de eerste n getallen van de rij van Fibonacci geeft. Bijvoorbeeld:
//echo -a $fibonacci(1)
1
//echo -a $fibonacci(6)
1 1 2 3 5 8
Ter controle: dit zijn de eerste 40 cijfers:
1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 17711 28657 46368 75025 121393 196418
317811 514229 832040 1346269 2178309 3524578 5702887 9227465 14930352 24157817 39088169 63245986 102334155
Voor degenen die de rij van Fibonacci niet kennen: Un = Un-1 + Un-2 met U1 = U2 = 1 (AKA, 't is de som van de twee voorgaande cijfers, te beginnen met twee enen)
