mirc scripting (especial de jamon)

Manual de Scriptig Por [ESpEcIaL[De]^[JaMon]^

Baja el FîãMbRe S¢rìÞT ® ßëTã 1.0 www.geocities.com/especial_de_jamon/

1

[ESpEcIaL[De]^[JaMon]^

www.geocities.com/especial_de_jamon

Scripting en Español para mIRC



2

IIINNNDDDIIICCCEEE TTTEEEMMMAAATTTIIICCCOOO Introducción................................................................................................... pág. 4 Conceptos Básicos......................................................................................... pág. 5 - Qué es el mIRC....................................................................................... pág. 5 - Etica del Scripter..................................................................................... pág. 8 Alias............................................................................................................... pag. 9 - Comandos................................................................................................ pág. 9 - Brackets................................................................................................... pág. 14 - Brackets llave.......................................................................................... pág. 17 - Comando If-then..................................................................................... pág. 17 - Comando goto......................................................................................... pág. 18 - Comentarios............................................................................................ pág. 19 - Comandos de mIRC para Aliases........................................................... pág. 20 - Cuadro de Modos.................................................................................... pág. 37 Popups............................................................................................................ pág. 38 Remotes......................................................................................................... pág. 44 Variables........................................................................................................ pág. 46 Identificadores............................................................................................... pág. 49 - Identificadores de tiempo y fecha........................................................... pàg. 51 - Identificadores de numero y texto........................................................... pág. 52 - Identificadores de archivos y directorios................................................ pág. 53 - Identificadores de nick y direcciones...................................................... pág. 55 - Identificadores de ventanas..................................................................... pág. 57 - Identificadores diversos.......................................................................... pág. 58 Eventos Estandar............................................................................................ pág. 60 - Sintaxis de los eventos............................................................................ pág. 62 Usuarios Remotos y Eventos CTCP.............................................................. pág. 74 - Comandos................................................................................................ pág. 74 - Eventos CTCP......................................................................................... pág. 75 - Usuarios Remotos................................................................................... pág. 78 - Restricciones de acceso a los eventos..................................................... pág. 80 Numeros y Eventos RAW.............................................................................. pág, 84 - Eventos RAW..........................................................................................pág. 88 - Numeros RAW........................................................................................ pág. 90 Contorl de Sockets en el mIRC...................................................................... pág. 92 - Identificadores de sockets....................................................................... pág. 92 - Abrir y Cerrar conexiones....................................................................... pág. 95 - Leer y Escribir informacion.................................................................... pág. 96 If-Then-Else................................................................................................... pág. 97 Comando GOTO............................................................................................ pág.102



3

Ventanas Personalizadas Estandar................................................................. pág.104 - Creacion de ventanas...............................................................................pág.105 - Edicion y Modificacion de Ventanas...................................................... pág.107 - Identificadores de ventanas Personalizadas............................................ pág.111 - Popups de Ventanas Personalizadas en Remotes.................................... pág.112 - Eventos comunes en Ventanas Personalizadas....................................... pág.114 Ventanas personalizadas de Imagen.............................................................. pág.118 - Comandos para Modificacion................................................................. pág.120 - Identificadores de Ventanas de Imagen.................................................. pág.125 - Eventos y Remotes en Ventanas de Imagen........................................... pág.126 Tutorial de Dialogos en el mIRC................................................................... pág.132 - Creando un Dialogo................................................................................ pág.132 - Poner elementos en el dialogo.................................................................pág.134 - Escribir texto en el dialogo..................................................................... pág.134 - Crear zona de edicion.............................................................................. pág.135 - Añadir una casilla.................................................................................... pág.135 - Añador un boton...................................................................................... pág.136 - Caja (Frame)............................................................................................pág.137 - Poner Icono............................................................................................. pág.137 - Crear lista desplegable............................................................................ pág.138 - Crear Combo Box................................................................................... pág.139 - Poner y borrar texto en dialogo creado................................................... pág.139 - Agrupar botones...................................................................................... pág.140 - Cambios de apariencia............................................................................ pág.141/144 - Marcado/desmarcado Radio/combo....................................................... pág.142 - Poner y Sacar foco.................................................................................. pág.143 -Activar/Desactivar Elementos.................................................................. pág.143 - Ocultar/Mostrar Elementos..................................................................... pág.144 - Otros Comandos...................................................................................... pág.146 Comando /dialog............................................................................................ pág.147 - Tablas de Dialogo................................................................................... pág.149 -Identificador $dialog................................................................................ pág.155 Comando /did................................................................................................. pág.156 - Identificador $did.................................................................................... pág.157 El Evento "On 1: Dialog".............................................................................. pág.158 Agradecimientos............................................................................................ pág.163



4

Scripting en Español para mIRC

INTRODUCCION Esta es una recopilación de información acerca de algunos datos y formas necesarias para la creacion de un Script para el mIRC. Espero sea de su entera utilidad. Quieres Crear tu propio Script? Bueno, este "manual" esta dedicado a ayudar a todos los que sueñan con hacer un script propio, tarea no pequeña y que conlleva muchos detalles, y a quienes como yo, se dieron mil veces contra la pared tratando de solucionar algun problema o implementar una idea nueva. Mi intencion es hacer la introduccion al scripting e ir avanzando poco a poco, con ejemplos. Es importante mencionar que cada uno de estos documentos, en gran medida, ya tiene su autor, lo que he hecho es transcribir los mas importantes y traducido algunos, aportado con lo que yo se al respecto, y por tanto hay que agradecer y dar credito a quienes antes que yo se preocuparon del tema, la constante asesoria de quienes son mas conocedores. La Motivacion principal que me impulso a la creaccion de este "Manual del Scripter", fue que cuando me decidi a realizar un script, no encontre un manual totalmente didactico y explicado de manera simple, 2+2=4. Aparte de encontrar la informacion de una manera muy atomizada, por lo que con lo aportado por mi, mas lo que ya se ha hecho al respecto, he tenido el atrevimiento de aparecer con este manual. Espero sepan disculpar los errores que se puedan encontrar, y si hay falta de claridad, en alguna parte de este documento esta mi email. Ademas nadie se ha preocupado en esta parte del mundo de hacer esto, que es muy necesario. Por ultimo, GRACIAS a todos, los amigos muy amigos, los amigos, los enemigos, que sin que ellos lo supieran yo ya tenia una copia de sus scripts antes de que salieran al "mercado" y asi porder estudiarlos, y a los conocidos por las gratas charlas. Si tienes alguna pregunta, duda, comentario, puedes encontrarme en conectados.ciudad.com.ar (6667) salon #Maduras_y_Maduros y en #Mas-de-Treinta-y-Tantos, o en irc.reuna.cl (6667) salon #chile y en #Mas-de-Treinta-y-Tantos. Mi nick es [ESpEcIaL[De]^[JaMon]^ y mi número de icq (lamers abstenerse) 49507978.



5

CONCEPTOS BASICOS

mIRC Scripting ¿Que es el mIRC? Es uno de los programas (o clientes) de IRC ( Internet Relay Chat ) mas populares hoy en dia, contando con versiones para win3.x y win95, 16 y 32 bit respectivamente. El objetivo de estas páginas es documentar en español las herramientas y técnicas necesarias para la creación de scripts para mIRC. De este modo, además de incrementar la escasa información de que se dispone en nuestro idioma, pretendo poner estos conocimientos al alcance de los nuevos y viejos creadores y de todos los usuarios que los necesiten, tanto para desarrollar y distribuir un script como para aplicarlos a la personalización de las propias sesiones en el IRC. En general podemos decir que un Script es una secuencia de instrucciones que un programa es capaz de seguir, interpretar, y ejecutar. Un script puede estar formado por una o más rutinas o grupos independientes de instrucciones. El mIRC dispone de un amplio entorno en el que podemos llevar a cabo la programación de rutinas de script, logrando así que el programa realice las funciones más diversas, permitiéndonos avanzar mucho más allá de las capacidades que este cliente de IRC implementa ya por defecto. Este programa (mIRC) tiene la particularidad de ser altamente modificable por medio de los scripts, de tal manera que se le agregan al mIRC funciones (scripts) que originalmente no estaban definidas o agregadas por el autor. A el conjunto de estas instrucciones, que llegan a ser de diversos grados de complejida, se les denomina "Scripts" (guion) y al acto de desarrollar un scripts, se le llama "scripting".



6

Prácticamente la totalidad de la configuración básica, tanto la que el programa realiza por sí mismo como la que nosotros especificamos en las distintas ventanas de diálogo es depositada en ficheros de texto con extensión .ini en el mismo directorio que el fichero ejecutable (mIRC16.exe ó mIRC32.exe), o en un subdirectorio de este. Es posible por tanto acceder a todos esos parámetros de configuración y editarlos según nuestros deseos. Así mismo, todos los scripts que creemos para el mIRC, con todas sus rutinas e instrucciones, se depositan también en ficheros. La creación, modificación, y carga de estos ficheros se puede hacer directamente desde el propio mIRC en las distintas opciones del menú Principal, Herramientas. La creación de scripts para mIRC potentes y útiles exige un buen conocimiento de los comandos generales de IRC, de los comandos propios del mIRC, y de las distintas áreas configurables de este programa. En este manual veremos el uso y utilidad de cada una de esas áreas configurables y como debe de trabajar con ellas; también tocaremos en capítulos aparte el uso de las herramientas imprescindibles para explotar todas las capacidades de este entorno. El mIRC te da acceso facil a varios comandos de IRC y comandos que son propios del mIRC para que puedas hacer que el mIRC reaccione de una manera u otra a los distintos estimulos que recibira en los canales del IRC. Si usted parte de cero, o desea iniciar un proceso de aprendizaje ordenado es siempre recomendable comenzar estudiando detenidamente los comandos, estas ordenes le darán una buena idea inicial de lo que el programa puede hacer y será la base fundamental con la que posteriormente deberá utilizar en la creacion del script. Es indispensable un buen nivel de conocimientos de órdenes y comandos antes de avanzar a las siguientes etapas. El siguiente paso lógico es comenzar a crear Alias y Popups, aquí ya descubrirá como con unos pocos comandos puede lograr efectos espectaculares en su programa. Tanto los alias como los popups se crearán en ficheros de texto independientes y cargados en el mIRC (mediante los comandos Cargar y Descargar). La capacidad de estos ficheros es grande pero limitada, ahora bien, usted podrá crear una buena cantidad de ellos si lo necesita.



7

Los POPUPS : Cuyo nombre completo es los Popup Menus. Que significa menus emergentes, o sea que aparecen cuando haces un click en el boton derecho de mouse en alguna de las areas de cualquiera de las ventanas visibles en el mIRC (Ventana del Salon, Ventana de Estado, Ventana de Lista de Nicks, Ventana de Privado o Query, Barra de Menu Principal). Los ALIAS : Son grupos (paquetes) de comandos reunidos en uno solo, de tal manera que al ejecutar el Alias como un comando unico, se ejecuta el grupo completo. Llegados a este punto ya se habrá encontrado con lo Identificadores, pero es el momento de estudiarlos más a fondo y observar lo que le permiten hacer. sus Alias y Popups multiplicarán su capacidad y eficacia con un buen uso de estos Identificadores. Si hasta ahora no se ha sentido tentado de estudiar el uso de Variables y de la estructura IF-ELSE es el momento de hacerlo. Si ya está familiarizado con algún tipo de programación los encontrará extremadamente simples, si no quizás le parezcan algo más complicados pero tómelo con calma, verá que una vez comprendidos son conceptos muy elementales y le permiten dar a sus rutinas una flexibilidad que antes no imaginaba. Si su practica y estudio ha llegado hasta aquí solo le queda adentrarse en el área que mIRC denomina "Remotes", es lo que le queda para poder hacer un script a la altura de los mejores. Estudie con detenimiento los Eventos, los Números Raw y los Sucesos CTCP. Los REMOTES : Son eventos que se disparan (o ejecutan) por algun estimulo en el salon, y que a su vez activan un comando o alias. El uso de Ventanas Personalizadas es un recurso muy vistoso y que da al script un aspecto original, pero el abuso de ellas, empleandolas para fines superfluos o cuando el programa ya dispone de una forma cómoda de suministrar la misma información delata a los creadores principiantes y hace más engorroso el manejo de su script. Estudie bien esta estapa nates de utilizarla por que puede ser un arma de doble filo.



8

Vamos a tratar de ver en un orden logico los comandos, Alias, Popups y Remotes, etc, de mIRC para que vayas comprendiendo como se hace esto del scripting. Antes de entrar en materia mas profunda es muy importante mencionar lo siguiente:

La Etica del Creador de Scripts Los scripters tenemos un codigo de etica no escrito que es bueno respetar. Poco a poco, conversando con otros scripters, te daras cuenta, pero lo basico es lo siguiente: 1- Nunca copies el script de otro, ni pegues pedazos de uno a tu script y digas que tu fuiste el creador o dueño.

2- Si incluyes porciones de otros Scripts, hazlo luego de pedir autorizacion al autor y dale credito. NO es facil hacer un Script.

3- Nunca preguntes sin haber investigado lo mas posible, y cuando preguntes se concreto en el cuaestionamiento, para obtener una respuesta facil, adecuada y rapida.

4- Una forma valida de aprender es viendo como hicieron los otros scripters para resolver un problema, y basarte en eso, pero creeme que si copias, alguien se dara cuenta.



9

Alias El mIRC te permite crear Aliases y Scripts para acelerar tus sesion de IRC o para desempeñar funciones repetitivas mas facilmente. Para crear aliases tienes que conocimiento sobre los comandos del mIRC o por lo menos tener o saber donde buscarlos, aqyu podras ancontralos. Los Aliases pueden ser llamados o ejecutados desde la linea de comandos, desde otros Aliases, y desde los Popups y los Remotes Scripts. Los Aliases no pueden autoejecutarse de manera continua por que esto parece causar mas problemas al usuario que resolverlos. Podemos pensar en un alias como un nuevo comando u orden para mIRC que creamos nosotros mismos. De esta forma automatizamos un proceso a fin de poderlo ejecutar más fácilmente. Encontraremos todos los alias de que disponemos en un momento determinado, en el menú Principal Herramientas, opción "aliases", es ahí donde debemos escribir los nuevos alias que creemos, o modificar los existentes, una vez hecho esto pulsaremos el botón OK, y el alias ya quedará cargado en nuestro programa. No obstante, antes de empezar a crear y modificar alias es preciso tener un buen conocimiento de los comandos del mIRC, puesto que son ellos los que forman el núcleo fundamental de las ordenes que se emplean en un alias. La definición de un alias se compone de dos partes: el nombre o patrón del alias, y las instrucciones que se ejecutarán cada vez que llamemos a este alias. Vamos a verlo con un ejemplo sencillo: Ejemplos : Los siguientes ejemplos te muestran como crear aliases que desempeñan funciones simples.

/gb /join #latinchat Este alias se llama "gb", y cada vez que en la línea de escritura pongamos: /gb, el programa ejecutará el comando: /join #latinchat.



10

Ahora si escribes /gb es lo mismo que si escribieras /join #latinchat ya que con el comando /gb grabas la orden que le sigue. Obsérvese que el nombre del alias debe de ir precedido del símbolo de comando "/". A continuación del nombre pondremos un espacio en blanco, y las ordenes que queremos que el alias ejecute al ser invocado. Estas ordenes serán normalmente otros comandos u otros alias. No es recomendable el uso de la recursividad, es decir, emplear el nombre del alias que estamos definiendo dentro de su propia definición.

/j /join $1 Ahora hemos agregado un string de parametro. Si escribimos /j #join (donde #gb es el salon grabado en el comando anterior) es lo mismo que escribir /join #gb. El $1 se refiere al primer parametro en la linea que escribes. (O sea que si hubieras escrito /j #latinchat, $1 se hubiera referido a #latinchat)

/yell /me $2 $1 Ahora si escribes /yell ..Hola Todos! .. el comando sera /me ..Hola Todos!.. El numero luego del $ especifica el numero del parametro que escribiste. Para una mayor claridad lo que en este caso quiere decir cada uno de los comandos en la linea /yell /me $2 $1 es : /yell = decir algo... /me = yo digo o hago algo /$1 = salon al que entro y digo o hago algo /$2 = lo que digo o hago

/jj /join $? El signo de interrogacion indica que se te preguntara o pedira que llenes este parametro $?. El parametro que des sera introducido en ese punto $? , donde ? sera lo que pongas. Asi que si escribes /jj te aparecera una ventana de dialogo preguntandote a que salon quieres entrar. Si pones #latinchat el comando final sera /join #latinchat

/jj /join #$1 El signo # indica que el parametro que especifiques sera precedido por el signo de numero (# = hash) indicando que es un salon. De manera que si pones latinchat ( sin el # ) el comando queda en /join #latinchat



11

/jj /join $?="En que salon quieres entrar?:" Esto hace lo mismo, pero ahora la ventana de dialogo va a tener la linea "En que salon quieres entrar?:" para que sepas que informacion se requiere. El comando /jj indica la aparicion de una venrana de dialogo de pregunta sobre el salon a entrar, claro que seguido de los comando antes mencionados. Si en la definición del alias queremos especificar varios comandos u ordenes, no nos vale la sintaxis anterior, a estos efectos disponemos de las llaves {} para encerrar todas las líneas del alias:

/gb {

/nick Froger

/join #Mas-de-Treinta-y-Tantos

/join #Maduras_y_Maduros

/mode Froger +i

}

Este alias cambiará nuestro nick, entraremos en #Mas-de-Treinta-y-Tantos y #Maduras_y_Maduros, y pondrá nuestro modo de usuario en +i (invisible). También sería posible especificar todos los comandos de alias en una sola línea utilizando el símbolo | (suele ser la combinación AltGr 1 o Alt 124): /gb /nick Froger | /join #Mas-de-Treinta-y-Tantos | /join #Maduras_y_Maduros | /mode Froger +i Evidentemente los alias no serian lo que son si no permitieran una mayor flexibilidad en sus definiciones. Imaginemos que no queremos especificar un nick para el alias /gb, ni tampoco los salones en que este nos debe de introducir, sino que deseamos que estos sean los que decidamos en cada momento que ejecutamos el alias. Esto es posible utilizando identificadores posicionales del tipo $nº de la siguiente forma:

/gb {

nick $1

join $2



12

join $3

mode $1 +i

}

De esta forma el alias esperará que nosotros especifiquemos el nick y los salones a continuación de la llamada, y sustituirá $1, $2, y $3 por la primera, segunda, y tercera palabra que escribamos detrás de la orden /gb. Para una mayor claridad, por ejemplo: /gb Froger #Mas-de-Treinta-y-Tantos #Maduras_y_Maduros La flexivilidad de este alias esta en que podremos decidir un nick y salones diferentes con solo ponerlos a continuación del nombre del alias, por ejemplo: /gb Fiambre #ayuda_mIRC #opers_ayuda

/aw /away $?="Ingrese el mensaje de ausencia:" | /say $! Este es similar al de arriba excepto por la adicion del parametro $!. Este se refiere al texto que acabas de meter en el cuadro de dialogo (o sea el mensaje de away), que sera el que aparezca cuando estes en el modo away. Esto te ahorra el trabajo de escribir el mismo mensjae dos veces. El comando /away $? Indica que te aparecera una ventana de dialogo en la cual debes ingresa o escribir el mensaje de ausencia. El comando /aw se utiliza para activar el modo away, claro que seguido de los comandos antes mencionados.

/give /me gives $$1 a $$2 El $$ doble significa que este comando solo se ejecutara si y solo si se especifica el parametro. Si solo especificas uno de los dos parametros en el comando de ariba, no se ejecutara. Tambien puedes poner $$?1 o $?1 lo que significa: "trata de llenar este parametro con el parametro 1 si este existe. Si el parametro 1 no existe pregunta por el". En el primer caso el parametro es necesario para que el comando sea ejecutado, en el segundo caso no. El comando /give se utiliza cuando queremos dar algo a alguien. El comando /me indica que soy yo quien ejecuto la accion, sea cual esta fuere.



13

/slap /me golpea a $1 con un $2- El $2- indica que el parametro 2 y todo lo que viene despues tienen que agregarse a la linea de comando. Si escribes /slap Idioton con un mazo de hierro la linea final sera /me golpea a Idioton con un mazo de hierro. Donde $1 es Idioton y $2 es mazo de hierro. Tambien puedes especificar $2-5 lo cual significa "usa solo los parametros del 2 al 5". El comando /slap se utiliza cuando queremos madar un golpe literariamente a alguien. El comando /me indica que soy yo quien ejecuto la accion, sea cual esta fuere.

/laugh /me se rie del chiste de $1's Todo lo que se ponga en el parametro $ aparecera al final de la frase. Asi que si escribimos /laugh mimi el comando final seria /me se rie del chiste de mimi. Hay ciertos signos que se pueden pegar al $, como el ' en este caso, que en ingles indica pertenecia. Tienes que experimetar para ver con cuales se puede y con cuales no

/silly /say Ho $+ la to $+ dos $+ ! Los parametros normalmente estan separados por un espacio. Para que mIRC combine los parametros, puedes usar el identificador $+ . La linea de arriba saldria asi: Hola todos! Esto es importante en los casos en que el $ no acepta un signo al lado suyo.

/p /part # El signo # se refiere al salon en que estas en el momento en que metes el alias. Asi que si estas en el salon #latinchat y pones /p mIRC reemplaza el signo # por #latinchat y el comando final seria /part #latinchat. El comando /p /part se utiliza cuando queremos salir de una salon determinado en el cual nos encontremos.

/op /mode # +o $1 Para darle op a alguien ahora solo escribes /op usuario, en vez del comando /mode completo. En este caso # indica el salon en donde esta la persona a la que daras op, +o indica el op propiamente tal y $1 a quien se lo daras. El comando /op se utiliza cuando quieres darle el op a un usuario determinado. El comando /modo indica el modo que le daras a un usuario o que activaras para ti.

/dop /mode # -ooo $1 $2 $3 Con esto puedes quitarle el op a tres usuarios escribiendo /dop fulano sutano mengano. En este caso el comando /modo indica el modo a ejecutar, # el salon



14

donde se ejecutara, -o significa quitar el op a un usuario determinado y $1 el usuario sobre quien se ejecutara la accion. El comando /dop o /deop se utiliza cuando queremos quitarle el op a un usuario determinado. En el ejemplo de arriva aparecen -ooo esto es por que son a 3 ($1 $2 $3) personas a las cuales vamos a quitar el op, es proporcional.

/dkb /kick # $1 | /mode # +b $1 Para poner comandos multiples debes usar el caracter | (en los teclados en español generalmente es altgr 1 o alt 124) Asi que para escribir un alias que patee y banee a alguien pon lo de arriva. En este caso el comando /dkb quiere decir dop o deop + kick + baneo, el comando /kick quiere decir patear o sacar a un usuario determinado del salon, # el salon donde se ejecutara la accion, $1 sobre quien se ejecutara la accion | carácter para poder poner comandos multiples seguidos, /mode indica el modo a ejecutar sobre el usuario determinado, # el salon donde se ejecutara la accion, +b indica que se aplicara el modo baneo que quiere decir que al usuario no se le permitira ingresar al salon otra vez y $1 sobre quien se ejecutara la accion.

Los brackets de evaluacion [ ] Si quieres mas control sobre el orden de evaluacion de los identificadores, puedes usar los parentesis cuadrados o brackets. Los Identificadores devuelven el valor específico, ejemplo.. $time devolvería la hora actual. Siempre quel mIRC encuentre el identificador en el comando, lo reemplaza con el valor actual de ese identificador. Muchos identificadores también realizan funciones en datos que proporcionas y entonces devuelven el resultado. Los odentificadores estan agrupados de la siguiente manera, Identificadores de Fecha y Hora, Identificadores de Ficheros y Directorios, Identificadores de Nick y Direcciones, Identificadores de Texto y Números, Identificadores de Símbolos, Identificadores de Ventana, Otros Identificadores. Mas adelante tocaremos a fondo este pinto de los Identificadorees.



15

Los identificadores que esten dentro de estos brackets seran evaluados primero, de izquierda a derecha. Tambien puedes meter unos dentro de los otros.

/say % [ $+ [ $1 ] ] Tambien puedes forzar la reevaluacion de un identificador previamente evaluado usando extra brackets [ ]

/set %x %y /set %y Hola! /echo [ [ %x ] ] En este caso donde /set %x %y son variables a definir, /set %y Hola! , es la definicion de la variable y, /echo [ [ %x ] ] es la reevaluacion de la variable x. El comando /say es una orden que solo se ejecuta desde dentro de un script, y equivale al comando /msg #. Es decir envía un mensaje al salon actual. Si a la hora de invocar un alias que contiene parámetros posicionales o del tipo $? omitimos la palabra por la cual estos deben de ser sustituidos (no ponemos un nick o unos nombres de salon en los ejemplos anteriores), el mIRC intentará ejecutar de todos modos el alias, y en la mayoría de los casos se producirá un error. Una alternativa interesante es hacer uso de la variación $$nº ó $$?. El doble signo $ hace saber al programa que si en la llamada a un alias no se da un valor a ese parámetro, debe de ignorar la orden. Por ejemplo: /saludo /say Hola $$1 , $2 , $3 .Bienvenidos, que la pasen muy bien!! Podemos ejecutar el alias /saludo especificando hasta tres nombres o palabras para ser incluidas en la línea del /say, pero funcionará igualmente si ponemos solo dos o una; sin embargo, si no damos al menos un valor tras la llamada /saludo el programa lo ignorará y no ejecutará acción alguna. Obsérvese que hemos tenido la precaución de definir los identificadores bien separados del resto del texto por espacios en blancos a derecha e izquierda, si no lo hacemos así el programa no los identificará como tales y los tomará literalmente como un texto. Si en alguna ocasión es preciso que la palabra que sustituya al identificador aparezca junto a otros caracteres que no sean blancos (signos ortográficos, paréntesis, el path de un fichero...etc.) podemos recurrir al



16

identificador $+, este lo único que hace es eliminar los espacios en blanco que tiene a derecha e izquierda en la presentación final de la línea. Por ejemplo: /fichero /say La ruta de mi cliente de IRC es: C:\mirc\ $+ $1 Si escribimos: /fichero mirc32.exe Obtendremos la línea: La ruta de mi cliente de IRC es: C:\mirc\mirc32.exe Donde $+ elimina los espacios en blanco y $1 es la informacion requerida para completar la accion. Una variante interesante de los identificadores $nº, $?, $$nº, y $$? la podemos lograr anteponiendo a los mismos el símbolo #; esto nos evita el tener que escribir siempre este símbolo antes del nombre cuando queramos introducir el nombre de un canal, puesto que el programa lo insertará automáticamente. Por ejemplo: /j /join #$?="En que salon quieres entrar? (sin #)" Otra opción muy útil de la creación de Aliases es la especificación de alias dirigidos a las teclas de función, es decir el nombre o patrón se asocia con las teclas F1 a F12, o bien de combinaciones de estas con los botones Shift y Control; de este modo solo es necesario pulsar la combinación de teclas correspondiente para que el alias se ejecute. Ejemplos: /F1 /say Hola $$?="escribe el nick a saludar:" $+ . Bienvenido al canal Con este alias no necesitamos más que pulsar F1 para que el programa nos pida un nick, y emita un mensaje de saludo a ese nick en el salon activo.



17

/sF2 /quit Adiós amigos, hasta pronto! Con este alias desconectaremos del server dejando un mensaje de despedida al pulsar las teclas Shift + F2 /cF3 /ctcp $$?="nick?" ping Con este alias podremos enviar un ping solo pulsando la combinación Control + F3 y escribiendo el nick que recibirá el ping.

Los brackets de llave { } Puedes crear scripts multilinea usando los { }. Esto te permite crear un alias que realice varios comandos. /poema { /msg $1 La distancia /msg $1 no es cuanto nos alejemos /msg $1 sino /msg $1 el que no nos olvamos a encontrar } Esto ejecuta los comandos en orden. Dicho sea de paso, en mIRC ya no es necesario poner el / antes del alias o comando. Este solo se pone si lo vas a escribir en donde normalmente escribes en el salon. pero si lo tienes en un archivo de alias, puedes poner asi: poema { msg $1 La distancia msg $1 no es cuanto nos alejemos msg $1 sino msg $1 el que no nos olvamos a encontrar }

El si-entonces ( if-then-else) Puedes usar el if-then-else para decidir que partes del script se ejecutan basandose en una evaluacion de una comparacion /numero { if ($1 == 1) echo El numero UNO elseif ($1 == 2) echo El numero DOS else echo Numero desconocido! }



18

Esto crea un alias que mira si el parametro que metiste es el numero 1 o el numero 2. Mas informacion sobre este comando tocaremos mas adelante en la parte de if-then-else

El comando Goto El comando goto te permite saltar de un lado a otro en el Script /numero { if ($1 == 1) goto uno elseif ($1 == 2) goto dos else goto desconocido :uno echo El numero UNO halt :dos echo El numero DOS halt :desconocido echo Numero desconocido! halt } Si usas el goto incorrectamente puedes ocasionar un loop (repeticion) infinito, estro tambien es muy util al momento de programar un Flood de ofensa. Puedes salirte de un loop presionando Control-Break (me ha sido imposible encontrar esta tecla en mi teclado, su la encuentras, mandame un email a [email protected] Nota : No se pusieron los / en los comandos de arriba. Esto es porque el / solo se necesita cuando metes un comando en la linea de escritura. En los Scripts, se asume que todas las lineas empiezan con un comando, asi que no necesitas el /. Si quieres forzar que un comando se ejecute silenciosamente, o sea sin regresar

ninguna informacion, puedes prefijarlo con un punto "." Por ejemplo: /ignore algunnick Nos mostraria informacion diciendote que ahora estas ignorando a "algunnick". Si no quieres que esta infromacion se muestre, entonces puedes usar: /.ignore algunnick



19

Comentarios Puedes agregarle comentarios a tus Scripts usando el punto y coma ; al comienzo de una linea.Y ;Esto es un comentario Puedes poner comentarios donde quieras en el Script, seran ignorados durante el proceso De lo visto hasta ahora se deduce fácilmente que la principal potencia de los alias reside en el uso de los identificadores $; hay otros muchos además de los que hemos descrito aquí, que proporcionan diferentes utilidades, una lista más detallada de estos se puede consultar en el apartado IDENTIFICADORES DEL mIRC. Otros recursos como el uso de variables, la instrucción if-else, ...etc. tienen también su capitulo aparte



20

Comandos de mIRC para Aliases

Se ha transcrito aqui parte de la traduccion de Champy [Hispano] y he agregado algunos nuevos que han salido junto con el mIRC 5.6 , de los comandos de mIRC y de IRC. Esta es una lista de todos los comandos disponibles (quizá existan mas), en esta sección he nombrado los comandos y una breve descripción de ellos, si no sabes que son los comandos te recomiendo que primero vayas a la sección Comandos Básicos para que los estudies con detenimiento. / Enseña el ultimo comando escrito en la ventana. /! Enseña el ultimo comando escrito en cualquier ventana. /action {texto} manda la acción especificada en el canal o “query” activo. /add [-apuce] {nombre_del_archivo.ini} hace un “load” de los archivos aliases, popups, users, commands y events. /ame {texto} Envía la ación especificada a todos los canales activos donde te encuentres. /amsg {texto} Envía el mensaje especificado a todos los canales activos donde te encuentres. /auser {nivel} {nick | dirección} Agrega un usuario “user” con el nivel de acceso especificado a tu lista de “remote users”. /auto [on|off|nick|direccion] Activa permanentemente el “auto-opping” ON o OFF del nick o dirección. /away {mensaje} Activa tu nick como ausente (away) del IRC dejando el mensaje especificado. /away Activa tu nick ya de regreso al IRC. /ban [#canal] {nick} [tipo] Hace un “ban” (expulsión permanente) al nick especificado en el canal especificado. /beep {numero} {retraso} Tu sistema hará un sonido “beep” el ‘numero’ de veces con un ‘retraso’ especifico. /channel Abre la ventana central de información del canal activo. /clear Borra todos los mensajes escritos en la ventana del canal. /ctcp {nick} {ping|finger|version|time|userinfo|clientinfo} Hace una de cualquiera de las funciones elegidas. /closemsg {nick} Cierra la ventana “query” que tienes abierta del nick especificado. /closemsg [nombreventana] Cierra la ventana de mensaje especificada. /creq [ask | auto | ignore] Programa tu DCC para tu configuración de 'On Chat request' de tus opciones DCC.



21

/sreq [+m|-m] [ask | auto | ignore] Este es el comando equivalente a las opciones de DCC Chat (mira /creq). Los parámetros +m|-m minimizan poniendo on|off. /dcc send {nick} {archivo 1} {archivo 2} .etc.... Envía los archivos especificados al nick especificado. /dcc chat {nick} Abre una ventana DCC y envía una petición de conversar por DCC al nick especificado. /describe {#canal} {texto} Envía la acción especificada al canal especificado. /disable {#nombre_del_grupo} Desactiva un grupo de comandos o eventos. /disconnect Obliga a el sistema a desconectarte rápido y bruscamente del servidor (úsalo con cuidado). /dlevel {nivel} Cambia el nivel del “user” al nivel especificado. /dns {nick | dirección IP | nombre IP } Usa el DNS de tu proveedor a resolver una dirección IP del nick especificado. /echo [nick|#canal|estado] {texto} Muestra el texto especifico únicamente a ti al lugar especificado. /enable {#nombre_del_grupo} Activa un grupo de comandos o eventos. /events [on|off] Enseña tus eventos “remote” y los activa o desactiva. /exit Obliga al mIRC a desconectarte del sistema. /finger #nick Hace un “finger” (información del usuario) del nick especificado. /flood [{numero_de_lineas} {segundos} {pausa}] Activa un control de “flood” como especificado. /fsend [on|off] Activa tu programa de envío de archivos permitiéndote elegir envío rápido o no. /fserve {nick} {maximo_numero_de_archivos} {directorio_de_destino} [texto de bienvenida] Abre tu “fileserver”. /guser {nivel} {nick} [descripción] Agrega al usuario “nick” especificado a tu lista de usuarios con el nivel y dirección especificada. /help {palabra} Activa el archivo de ayuda de comandos del IRC (bajo los archivos “help”). /ignore [on|off|nick|direccion] Activa o desactiva a tu sistema totalmente el ignorar a la persona “nick” o dirección. /invite {nick} {#salon} Invita a la persona “nick” al canal especificado /join {#salon} Te hace entrar al canal especificado. /kick {#salon} {nick} Hace un “kick” (sacar) al usuario “nick” especificado del salon. /list [#string] [-min #] [-max #] Nombra los salones existentes. /log [on|off] Enseña o no, los récords de la ventana activa. /me {texto} Envía la acción al salon o ventana activa de “query” (privado).



22

/mode {#chanal|nick} [[+|-]mode [parámetros]] Activa o desactiva los “modes” del canal o usuario. /msg {nick} {mensaje} Envía un mensaje privado en la ventana activa al “nick” seleccionado. /names {#chanal} Enseña una lista de los “nicks” de todos los usuarios en el salon especificado. /nick {nuevo nick} Cambia el nick al nick especificado. /notice {nick} {mensaje} Envía un mensaje en forma de noticia al “nick” especificado. /notify [on|off|nick] Te avisa si el “nick” especificado se conecta al canal o lo borra de tu archivo de notificación. /onotice [#salon] {mensaje} Envía un mensaje a todos los operadores del salon. /omsg [#salon]{mensaje} Envía un mensaje a todos los operadores del salon. /part {#salon} Te saca del salon especificado. /partall Te saca de todos los salones en los que te encuentres. /ping <dirección del “server”> Hace un Ping al server especificado mas NO a un nick. /play [-c] <nombre_del_archivo> [retraso] Te permite enviar archivos a la ventana. /pop <retraso> [#canal] <nick> Convierte a los usuarios en operadores por etapas de tiempo. . /protect [on|off|nick|direccion] Protege o no al nick especificado (y queda registrado en tu sistema). /query <nick> {mensaje} Abre una ventana nueva de “query” y envía el mensaje especificado privadamente . si se añade el parametro [-n], la ventana del query o privado se abrira minimizada. Ejemplo : /query [-n]<nick>[mensaje] /quit [razón] Te desconecta del IRC con el mensaje especificado (el mensaje es opcional). /raw [-q]<comando> Envía cualquier parámetro que le das directamente al servidor. Debes saber la sintaxis correcta del comando RAW que envias. Util para enviar comandos que mIRC no ha implementado todavía. La opción -q hace el trabajo raw calladamente y sin imprimir lo que está enviando. Este comando hace lo mismo que /quote en otros clientes de IRC. Ejemplo : /raw PRIVMSG nick : ¡¡¡¡¡Buenos dias a Todos!!!!! SI NO SABES DE QUE SE TRATA ESTE COMANDO RAW, NO LO USES!!!!!!!!!. /remote [on|off] Enseña el estado de tus comandos “remote” y los activa o desactiva. /rlevel {nivel de acceso} Remueve a todos los usuarios de el nivel especificado.



23

/run {c:\directorio\programa.exe} [parametos] Activa el programa especificado. /ruser {nick[!]|dirección} [descripción] Remueve a el usuario de tu lista de “users”. /save {nombre_del_archivo.ini} Hace un “save” del “remote” especificado en tu archivo INI. /say {texto} Dice lo que quieras en la ventana activa. Esto es útil en un alias cuando quieres hacer la misma pregunta (o envías la misma información) repetidamente. No puedes usar este comando en la sección remota. Usa /msg #canal <mensaje> en ese caso. Como ejemplo, puedes hacer tambien esto en la linea de comandos : /info /say "Por favor observa que el servidor de juegos está caido actualmente y estará offline durante unas horas..." /server [dirección del “server” [port] Te vuelve a conectar al ultimo “server” o al especificado. /sound [nick|#salon] {Nombre_del_archivo.wav} {texto} Envía el texto y el sonido del archivo especificado. /sreq [ask | auto | ignore] Programa tu DCC en 'On Send request' en tus opciones de DCC. /time Te da la hora actual del “server” al que estas conectado. /timer[N] {repeticiones} {intervalos en segundos} {comandos} [| {mas comandos}] Activa el reloj “timer”. /topic {#salon} {nuevo_titulo} Cambia el titulo del salon especificado. /ulist [{|}]{nivel} Enseña todos los usuarios en tu “remote” con el especificado nivel de acceso. /url [-d] Abre la ventana de tus URLs la cual te permite ver el www con tu buscador paralelamente al IRC. /uwho [nick] Abre la ventana de información del usuario “user central” con información especifica. /who {#salon} Enseña los “nicks” de todas las personas del salon. /who {*direccion_del.string*} Enseña todos los usuarios en el IRC con una dirección igual. /whois {nick} Enseña la información de la persona especificada en tu ventana de “status”. /whowas {nick} Enseña la información de un usuario que acaba de salir del IRC. /wavplay {c:\directorio\sounido.wav} Activa localmente el archivo wave seleccionado. /write [-cidl] {nombre_ del_archivo [texto] Escribe el texto especificado al archivo especificado de formato .txt /mode #salon +o {nick} Pone modo op a un usuario determinado, en un salon /mode #salon +ooo nick1 nick2 nick3 Da op a varios usuarios determinados /mode #salon -o {nick} Para quitar el op a un usuario determinado /mode #salon +b {nick} (o dirección{host}del usuario) Para banear a un usuario ejemplo de baneo por nick: /mode #scripters +b PorotoMan ejemplo de baneo por host o direccion : /mode #scripters +b [email protected]



24

/mode #salon -b nick (o dirección{host}del usuario) Para desbanear a un usuario. ejemplo de desbaneo por nick: /mode #scripters -b PorotoMan ejemplo de baneo por host o direccion : /mode #scripters -b [email protected] /mode #salon +i Para hacer salon solo para invitados /alias [nombre archivo]<nombre de alias><comandos> Para hacer alias Para Hacer, Agregar, quitar, reemplazar alias; se limita a líneas de alias y no afecta a las líneas múltiples definidas. /alias /fiambre2 /me mugidos Para agregar un nuevo alias, puedes usar Esto agregará el alias /fiambre2 a la cabeza de la lista de los alias.: /alias /fiambre2 Para quitar un alias que existe /alias moofiambre3.txt /fiambre3 /me mugidos Para agregar un alias a un archivo de alias específico.Si no especificas un archivo, tienes como valor predefinido los primeros archivos en los que el alias existe, o si no existe, entonces usa el primer archivo de alias cargado. /amsg /ame <mensaje> Envía el mensaje especificado o la acción a todos los canales en los que estes actualmente. /background [-amsgdluhcfnrtpx][ventana][archivo] Cambia el dibujo de fondo que pone para una ventana. Esto también puede cambiarse en la ventana Menú Sistema. Codigos de ventanas: -a = ventana activa -m= ventana principal de mIRC -s = ventana de estado -g = ventana finger -d = ventana de querys -e = poner por defecto -l = barra de herramientas -u = botones de la barra de herramientas -h = menú de la barra -x = ningún fondo en la ventana

-cfnrtp = -{c=centro, f=entero, n=normal, r=estirado, t=azulejo, p=fotografía} Puedes pulsar el botón derecho del mouse en toolbar/switchbar para que salga un menú y poder cambiar los dibujos. La Barra de herramientas puede usar un



25

color RGB 192,192,192 para transparencias, el BMP debe ser de la misma forma que las fuentes de mIRC. Debe ser 16 o 256 colores BMP. Nota: El nombre de la ventana sólo debe especificarse si ninguno de los parámetros se especifica. El nombre del fichero no necesita ser especificado si cambias sólo el método de desplegarse el fondo. /ban [-ruN] [#canal]<nick|address>[tipo] Para hacer una prohibición o baneo a alguien del canal actual que usa esa dirección. Esto hace un /userhost primero en la dirección del usuario mediante el [-ruN]+<nick|address>, y entonces hace un /mode #+b <dirección del usuario>. Si especificas la opción de -uN entonces el mIRC hace una pausa N segundos antes de quitar la prohibición. Si especificas -r entonces /ban quita la prohibición del tipo especificado para ese nick, ej: /ban -r nick 2 Si no especificas un tipo de baneo, entonces mIRC usa el nick!*[email protected] entero para hacer el ban. Si estás baneando una dirección IP entonces un comodin reemplaza el último número de la dirección IP. Si estás en el salon la especificación de #salon no es necesaria. Para ver una lista de tipos de ban mira el identificador $mask. /beep <número><retardo> Número de Pitidos con un retardo. /clear [-sghlc][nombreventana] Borra el texto de la ventana actual. Si especificas un nombre de ventana, se borra de esa ventana. Codigos de borrado de ventanas El parámetro -s borra la ventana de estado (status). El parámetro -g borra la ventana finger. El parámetro -l borra el "listbox" en una ventana personalizada. El parámetro -c borra el botón historia en una ventana de dibujo. El parámetro -h borra el comando history de una ventana. /clipboard <texto> Copia el texto especificado al escritorio. /close [-icfgms @][nick1]...[nickN] Cierra todas las ventanas del tipo especificado y nicks. Si no hay ningún nick, todas las ventanas del tipo especificado serán cerradas. El tipo de ventana es señalado por c para la de chat, f para la de fserve, g



26

para get, i para las ventanas de dcc inactivas, m para la de mensajes (query), s para envíos, y @ para las ventanas personalizadas. /colour <nombre><número> Permite cambiar las opciones de color en el menú de Colores. /copy -ao <archivo><archivo> Copia un archivo a otro archivo o directorio. También puedes usar comodines para el nombre del archivo inicial, y un nombre para el directorio de destino. El parámetro -o borra un archivo si existe. El parámetro -a añade el primer archivo al segundo. /creq [+m|-m][ask | auto | ignore] Este es el comando equivalente a las opciones de DCC Chat (mira /sreq más adelante). Los parámetros +m | -m minimizan y ponen las opciones en on | off. /ctcpreply <nick><ctcp>[mensaje] Envía una contestación a una pregunta ctcp. /ctcpreply goat HELP No hay ayuda disponible. /dll <nombre.dll><nombreproc>[datos] Esto te permite llamar rutinas en una DLL (librería) diseñada para trabajar con mIRC. /dns [-ch] [nick|dirección] Este comando Resuelve una dirección. Si mIRC ve un "." en el nombre especificado asume que es una dirección e intenta resolverla. Por otra parte, para el nick hace un /userhost para encontrar la dirección del usuario y entonces resolverla. Si le das una dirección IP, busca el nombre del host. El parámetro -c borra todos los DNS que estan en espera, excepto el que está actualmente en marcha. El parámetro -h obliga a /dns a tratar el parámetro como host. Puedes hacer múltiples /dns en espera, y ver el estado de la cola actual usando /dns sin parámetros en la linea de comandos. Nota: Debido a la forma en que trabaja la búsqueda de DNS, cualquier DNS buscado se resuelve, ejemplo: connecting to a server, debe resolverse antes de las demandas siguientes. Esto significa que si un DNS anterior está teniendo problemas al resolverse, los DNS siguientes tienen que esperar hasta que el cronómetro quede fuera de tiempo antes de que ellos puedan resolverse. /dqwindow [on|off|show|hide|min] Manipula en la ventana de query. /echo [númerocolor]<-dehiNtsaql|#salon |[=]nick><texto> Imprime el texto en la ventana especificada con el color especificado (0 a 15). /echo 3 Comprobando #mIRC Imprime "Comprobando" en color verde 8el cual corresponde al numero 3) en la ventana del salon #mIRC, asumiéndo que ya está



27

abierto. Si salon/nick no se especifica, el -s cambia mensajes a la ventana de estado, el -d cambia a la ventana de querys, y el -a hacia la ventana actualmente activa. El -e adjunta la línea en líneas separadas. El -iN realiza sangrías en la línea N carácteres. El -h fuerza el tamaño de la ventana y no cambia la línea. El -t cambia la línea con un timestamp si el tiempo está activado en esa ventana. El -q hace que no se muestre el texto si fué llamado desde un alias usando el prefijo. El -l lo aplica a las opciones de Resaltes en la línea mostrada. Nota: Este texto sólo se muestra en tu ventana, no se envía al servidor y asi nadie más puede verlo. /editbox [ -sap|[=]ventana]<texto> Rellena el editor de la ventana actual con el texto especificado. El interruptor -s indica la ventana de Estado. El interruptor -a indica la ventana Activa. El interruptor -p indica que un espacio debe añadirse al texto. Nota: Para especificar una ventana de charla dcc, pon delante del nick un signo = igual. /filter [-sgdfwxnpriocteu][n-n2][c s]<infile|dialog id><outfile|dialog id><matchtext> Este comando examina líneas de texto en una ventana o archivo y si cualquiera de ellos contiene matchtext, ellos se escriben en otra ventana o archivo que puedes usar entonces. Los infile pueden ser un nombre de archivo o ventana (personalizada o normal). Los outfile pueden ser un nombre de archivo o ventana personalizada. Debes especificar los parámetros -fw si los nombres son ambiguos, ejemplo:

/filter -ff in.txt out.txt *mirc* Esto indica que los dos son nombres de archivo. /filter -wf #in.txt #out.txt *help* Indica que el primero es un nombre de la ventana, y el segundo es un nombre de archivo. El -x excluye líneas emparejadas. El -n cambia líneas de prefijos con un número de línea. El -s cambia el infile a la ventana de estado. El -g cambia el infile a la ventana finger.



28

El -d cambia el infile a la ventana de mensajes. El -p cambia la salida del texto a una ventana personalizada. El -r especifica el rango de líneas por filtrarse de n a n2. El -i indica que has puesto un [dialog id] como control de diálogo personalizado de entrada. El -o indica que has puesto un [dialog id] como control de diálogo personalizado de salida El -c borra el archivo de salida windows/file antes de escribir. El -t ordena la salida [c s] columna C, siendo S el separador de columnas. El -e especifica orden descendente y -u orden númerico. Este comando también rellena el identificador $filtered con el número de palabras encontradas, si las hay. Nota: Si los archivos de entrada y salida son los mismos, mIRC procesará lo requerido correctamente. /findtext -n <texto> Busca en la ventana activa el texto especificado como (Control-F) /flash [-wbrN] <texto> Esto activa-enciende el icono/windows de mIRC con el texto especificado en la barra de tareas pero sólo si mIRC no es la aplicación activa. El parámetro -b hace que mIRC emita una señal sonora cada segundo. El parámetro -rN hace que mIRC repita el flsh solo N veces. El parámetro -w hace que mIRC toque el sonido especificado en la sección Pitidos a Sucesos ó Events Beeps.

/flushini <nombrefichero> Pasa los archivos INI especificados al disco duro. Se guardan los archivos INI en memoria, así que puedes hacer esto para asegurarte que tus archivos INI estan puestos al día. /font [-asgb|ventana]<tamañofuente><nombrefuente> Esto te permite cambiar el conjunto de caracteres para la ventana actual. Si no se especifica ningún parámetro, la ventana de diálogo de fuentes, usa los parámetros por defecto. Puedes hacer la negrita usando el parámetro -b. /join [-inx]<#canal> Este es el comando IRC normal para entrar en un salon. El -i te hace entrar al salon al que fuiste invitado en último lugar. El -n y -x cambia la ventana del salon a minimiza/maximiza, cuando entras.



29

/linesep [-s|ventana] Muestra el separador de línea seleccionado en la sección Extras en la ventana especificada. /links Muestra los servidores a los que tu servidor actual está unido. /load </a|-pscqnm|-ruvsN><nombrefichero> Carga los alias, popups, o scripts especificados. /load -a aliases.ini carga un archivo de alias /load -pc status.ini carga un popup del salon /load -pn status.ini carga un popup de la lista de nicks /load -ru users.ini carga un archivo de usuarios /load -rv vars.ini carga un archivo de variables /load -rs script.ini carga un archivo de scripts /loadbuf [líneas][-psglecoNt<topic>]<ventana | dialog id><nombrearchivo> Cargas el número especificado de líneas del archivo citado en la ventana especificada. /loadbuf 20 @test info.txt Esto carga las últimas 20 líneas de info.txt en la ventana personalizada @test. /loadbuf 10-40 @test info.txt Esto carga las líneas 10 a 40 de info.txt en la ventana personalizada @test. El -p fuerza las líneas de texto para mostrarlas en la ventana. El -s y -g aplica el comando a las ventanas de estado y finger respectivamente. El -l aplica el comando a la lista de una ventana personalizada. El -e evalúa variables e identificadores en la línea leida. El -cN especifica el color del fondo predefinido para las líneas. El -t carga el texto bajo el [topic] en la sección INI o en un archivo de texto. El -o indica que has especificado un parámetro [dialog id] en lugar de un

nombre de ventana para cargar texto en un control de diálogo personalizado.

/log <on|off><ventana>[-f nombrearchivo] Activa o desactiva el grabar la conversacion de una ventana, si especificas el nombre de un archivo determinado la ventana de diálogo no se muestra. /mdi -act Permite colocar iconos y ventanas en cascada/mosaico. /mkdir <nombredirectorio> Crea el directorio especificado.



30

/play [-escp q# m# rl# t#][canal/nick/stop]<archivo>[retardo] Este es un comando potente que te permite enviar archivos de texto, o partes de ellos, a un usuario o un canal. El retardo está en milisegundos. Si envias el archivo demasiado rápido al servidor probablemente serás desconectado por inundar este. La opción por defecto es 1000 ó sea 1 segundo. Se pueden enviar líneas vacías entre el texto para simular un retraso. /play c:\text\mypoem.txt 1500 Ejecuta archivo en la ventana activa con retraso El parámetro -e permite hacer eco del texto a una ventana cuando se envia al servidor. El parámetro -s permite usar el comando play en la ventana de estado mientras estas desconectado. Si no especificas el -s debes conectarte a un servidor para usar el comando /play. El parámetro -c obliga a mIRC a interpretar líneas como texto normal. El comando /play tiene "queues" ó colas para los usuarios; hace esto, porque si intentara usar todas las demandas al mismo tiempo, probablemente sería desconectado del servidor por inundar. El parámetro -p indica que ésta es una demanda con prioridad y debe ponerse a la cabeza de la cola para ser ejecutada de inmediato. La demanda en curso hará una pausa y se resumirá una vez que esta demanda se termine. El parámetro -q# especifica el número máximo de demandas que pueden estar en cola. Si la longitud de la cola ya es más grande que o igual al número especificado, entonces la demanda se ignora. Ejemplo : /play -q5 c:\text\info.txt 1000 El parámetro -m# marca los límites del número de demandas que pueden pasar a cola por un usuario/canal específicos. Si el usuario/canal ya tiene o excede el número especificado de demandas hecho cola entonces se ignora. Ejemplo : /play -m1 info.txt 1000 La línea anterior limita a cada usuario a un máximo de demandas en un momento e ignora todas sus otras demandas. Nota: El -q# y -m# sólo se aplican a comandos /play de definiciónes remotas,no tuyas.



31

Para combinar los parámetros anteriores harías: /play -cpq5m1 info.txt 1000 El parámtero -r fuerza una sola línea escogida al azar de un archivo. Por ejemplo : /play -r action.txt 1500 El parámetro -l# fuerza el número de línea especificado para ser leído de un archivo. Por ejemplo: /play -l25 witty.txt 1500 Para -r y -l# la primera línea en el archivo puede ser un solo número que especifica el número de líneas en el archivo, esto acelera el proceso de lectura del archivo. El parámetro -t cambia y obliga a mIRC a buscar el tema especificado en el archivo y mostras todas las líneas después de ese tema. Por ejemplo: /play -thelp1 c:\help.txt Em este caso, en el archivo help.txt tendrías: [help1] línea1 línea2 línea3 [help2] ... mIRC mostrará todo después de [help1] y se detiene cuando alcanza el próximo título o el extremo del archivo. También puedes usar el identificador $pnick en comandos que identifican el nick/salon al que estás ejecutando. Puedes usar stop, para dejar de ejecutar un archivo de texto y borrrar la cola, /play stop. /remove <archivo> Anula el archivo especificado. /rename <archivo><nuevoarchivo> Renombra un archivo, también puede usarse para mover un archivo de un directorio a otro. /resetidle [segundos] Resetea el identificador $idle para poner a cero o al número de segundos especificado. /rmdir <directorio> Anula el directorio especificado. Si el directorio tiene archivos, no puede anularse. /run [-n] <archivo>[parámetros] Ejecuta el programa especificado con parámetros. Por ejemplo : /run c:\net\ftp.exe sunsite.unc.edu, esto ejecuta el programa ftp con el parámetro sunsite.unc.edu.



32

/run notepad.exe $?="Que archivo deseas ver" Esto pide un parámetro y abre el bloc de notas con el archivo. Si especificas un archivo no-ejecutable, mIRC intenta encontrar el programa asociado con ese archivo y entonces lo ejecuta. Por ejemplo: /run info.txt......Puedes especificar -n para minimizar la ventana del programa que se ejecuta. /save <-pscqnm|-ruv><archivo> Graba el popup o el archivo remoto users/variables especificado. /save -ps status.ini graba el popup de estado a status.ini /save -pn nick.ini graba el popup de lista de nicks a nick.ini /save -ru users.ini graba la lista de usuarios a users.ini /save que -rv vars.ini graba la lista de variables a vars.ini Nota: Puedes grabar sólo una sección cada vez. /savebuf [-sga][líneas]<ventana><archivo> Graba el número especificado de líneas del buffer de la ventana especificada en el archivo citado. /savebuf 20 @test info.txt Esto graba las últimas 20 líneas de la ventana personalizada @test en info.txt. /savebuf 10-40 @test info.txt Esto graba las lineas 10 a 40 de la ventana @test en info.txt. El parámetro -s graba el buffer de la ventana de estado, el parámetro -g graba el buffer de la ventana digital, y el parámetro -a le hace añadir el texto al extremo de un archivo en lugar de borrarlo. /saveini Actualiza los archivos INI de mIRC con las opciones actuales. /server [-sar]<server/nombregrupo>[puerto][password] Te conecta a un servidor, primero desconectándote del servidor actual. Por ejemplo : /server irc.server.co.uk 6667 password. Si usas el comando server mientras estas conectado, serás desconectado con normal mensaje de despedida y te conectará al servidor especificado. También puedes usar /server N que conecta al servidor que está situado en la posición N de la lista de servidores. También puedes usar /server nombre de grupo, entonces se hará un ciclo a través de todos los servidores que en la lista de servidores tienen ese nombre de grupo hasta que te conecte a uno de ellos. Si especificas cualquier opción -sar, el formato del comando se vuelve: /server -sar[server][-p puerto][-g grupo][-w password][-d descripción] -s ordena la lista de servidores -a añade un server. Si existe, lo actualiza -r remueve un servidor



33

/showmirc -nrstx Manipula el despliegue de la ventana principal de mIRC, donde -n = minimiza, -r = restaura, -s = parpadea, -t = a barra de windows, y -x = aumenta al máximo. /sline [-a|r]<#salon><N|nick> Selecciona o desselecciona una linea en la lista de nicks del salon. O puede seleccionar el de la posición N, o un nick especificado. Si no especificas ningún parámetro, cualquiera que exista en la lista se borra. Si especificas el parámtero -a entonces los especificados se seleccionan sin afectar otras líneas. Si especificas -r es abarcado todo el artículo especificado. /speak <texto> Envía el texto especificado al Monólogo (o Text Assist) qué es un programa que habla cualquier texto que se le envía. /splay [-qwm]<archivo> Hace sonar el .wav especificado o el archivo .mid. Si no especificas un directorio, el directorio de Petición de Sonidos toma las opciones usadas. También puedes usar /splay stop que detiene un archivo que está sonando. El parámetro -q permite hacer cola a los .wav y .mid para sonar. Los parámetros -wm se usan junto con /splay -wm stop, y te permite especificar si quieres detener .wavs, .mids, o ambos. /strip [+-burc] Controla códigos de letras y colores, también pone las Opciones en on/off. /strip +bur-c Pone negrita, subrayado, inversa en on, y desactiva colores poniendo off. /timer[N/nombre][-ceom][tiempo]<repeticion><intervalo><comando> Activa el cronómetro citado para realizar el comando en un intervalo, y opcionalmente en un momento especificado. Si no te conectas a un servidor y activas un cronómetro, tiene un valor predefinido siendo un cronómetro offline, que continuará corriendo si te conectas a un servidor o no. Si te conectas a un servidor y activas un cronómetro, tiene un valor predefinido siendo un cronómetro online, que si desconectas del servidor, se apagará. Puedes especificar mediante -o para obligarle a que sea un cronómetro offline. /timer1 0 20 /ame ¡ está LEJOS ! Timer1 repetirá la acción al canal cada 20 segundos hasta que pares el cronómetro. Si especificas un retraso de 0 segundos, el cronómetro se activará inmediatamente después de que el script llegue al final. /timer5 10 60 /msg #Mas-de-Treinta-y-Tantos Para más informacion sobre este script /msg PorotoMan info. Timer5 repetirá este mensaje en el canal #Mas-de-Treinta-y-Tantos cada sesenta segundos y se detendrá después de 10 veces.



34

/timer9 14:30 1 1 /say son ahora las 2:30pm Esto esperará hasta las 2:30pm y anunciará entonces la hora y se parará. Para ver una lista de cronómetros activos teclea /timers. Para ver las opciones de timer1 escribe /timer1. Para desactivar timer1 escribe /timer1 off. Para desactivar todos los cronómetros teclea /timers off. Si estás activando un nuevo cronómetro que no necesita especificar el número del cronómetro, sólo usa: /timer 10 20 /ame ¡ Yo no estoy aquí ! y el mIRC asignará el primer cronómetro libre a este comando. Si especificas -m , indicas que el retardo del intervalo está en millisegundos. Si especificas -e , esto ejecuta el comando asociado con el nombre del cronómetro especificado. Nota: los cronómetros en milisegundos pueden reducir la velocidad mIRC bastante porque cada cronómetro puede activarse muchas veces por segundo, así que no deben usarse a menos que sean necesarios. El identificador $ltimer da el número del cronómetro que fué activado por /timer. En lugar de usar un número puede especificarse también un nombre. /timershow 0 10 eco -un $nick $server $time Puedes obligar a reevaluar el identificador cuando uses el comando /timer usando el formato $!me o $!time. Si desea desactivar un grupo de cronómetros, puedes usar un comodin para el número, por ejemplo: /timer3? Desactivado Desactiva los cronómetros del 30 al 39. /timestamp [-s|a|e][on|off][ventana] Activa poner- tiempo en sucesos on/off , e intenta poner-tiempo a la mayoría de los sucesos que ocurren. -s = para la ventana de estado -a = para la ventana activa -e = para cualquier ventana Si no se especifica nombre de ventana, entonces el interruptor global se activa o desactiva. /titlebar [@ventana]<texto> Pone el título en la aplicación principal. Si especificas una ventana personalizada, entonces se cambia el título de esa ventana.



35

/tokenize <c> <texto> Completa los identificadores $1 $2 ... $N con simbolos en <texto> separado por carácter <c>, ejemplo: /tokenize 44 a,b c,d,e El comando anterior pondria $1=a, $2=b c, $3=d, $4=e /unload <-a|-rs><archivo> Descargas los alias o el archivo script remoto seleccionado. /unload -un aliases.ini descarga el archivo alias.ini /unload -rs script.ini descarga el archivo script.ini Nota: Puedes descargar sólo una sección de cada vez. /updatenl Actualiza el salon, la lista de nicks y IAL en scripts remotos de kick/part/quit. /winhelp <archivo>[key] Abre un archivo de ayuda con la palabra de búsqueda especificada. /write [-cida l# s#]<archivo>[texto] Escribe líneas a un archivo del texto. Por ejemplo: /write store.txt Esta línea se añadirá al archivo store.txt El parámetro -c borra el archivo completamente antes de escribir en él, así que empieza con una pizarra limpia. Por ejemplo: /write -c c:\info.txt Este archivo se borrará y esta línea se escribirá en él. El parámetro -l# especifica el número de la línea donde el texto se escribirá. Si no especificas un número de línea, entonces la línea se agrega al final del archivo. Por ejemplo: /write -l5 c:\info.txt Esta línea borrará la línea 5 en el archivo. El parámetro -i indica que el texto debe insertarse en la línea especificada en lugar de borrarlo. Si no especificas ningún texto entonces una línea blanca se inserta. Si no especificas un número de línea entonces una línea blanca se agrega al final del archivo. Por ejemplo: /write -il5 c:\info.txt que Esta línea se insertará en la línea 5 del archivo El parámetro -d anula una línea en el archivo. Si no especificas un número de línea entonces la última línea del archivo se anula. Por ejemplo: /write -dl5 c:\info.txt El comando anterior anulará la línea 5 en el archivo. El parámetro -s# examina un archivo por la línea que empieza con el texto especificado y ejecuta la operación en esa línea. Por ejemplo: /write -dstest c:\info.txt, Esto buscará en el archivo info.txt una línea que empieza con la palabra "test" y si la encuentra, la borra. Si no especificas ningún parámetro entonces el texto simplemente se agrega al final del archivo.



36

El parámetro -a indica a el mIRC que debe añadir la línea de texto que especificaste al texto que existe en la línea señalada. /writeini -n <archivoIni> <sección> [artículo] [valor] Escribe en los archivos INI en el formato normal de archivo. Si el parámetro -n es especificado, mIRC intentará escribir el archivo .ini aunque sea más grande de 64k. Una parte del archivo de mirc.ini se parece: [DDE] ServerStatus=on ServiceName=mirc Podrías lograr esto usando /writeini : /writeini my.ini DDE ServerStatus on /writeini my.ini DDE ServiceName mirc Puedes anular secciones enteras o artículos usando el comando /remini. Atencion: No use este comando para modificar cualquiera de los archivos INI que estan siendo utilizados por mIRC.



37

========================================================= Modos de Salon

===========================================================

Modos Efectos en Salones =========================================================== b <usuario> banea a alguien, <usuario> en sintaxis "nick!user@host" i el Salon es solo para invitados l <número> el Salon es limitado, <número> usuarios máximos

permitidos. m el Salon está moderado, (solo operadores hablan) n /MSGs externos no se emiten en el Salon o <nick> hace al <nick> operador en el Salon p el Salon es privado s el Salon es secreto t topic limitado, solo operadores pueden cambiarlo k <key> pone clave secreta <key> para entrar al Salon =========================================================== ===========================================================

Modos Usuarios ===========================================================

Modos Efectos en nicks =========================================================== i hace invisible a alguien que no sepa la ortografía exacta de tu nick o estado de IRC-operador, solo puede ponerse por IRC-ops con OPER s recibe noticias del servidor v voz, puede escribir en un canal moderado ===========================================================



38

Popups

mIRC te permite crear menus que brotan haciendo un click con el boton derecho del mouse (popups) para la ventana de status, para la ventana de query/chat(privados), para la ventana del salon, para la lista de nombres(nicknames list), y para la barra principal de menus. Para crear estos debes saber como usar los comandos basicos de mIRC, como crear aliases, como usar identificadores y variables. Ejemplos: Los Popups usan este formato: <menuitem>:<comandos> Buscar ayuda:join #scripters Las palabras antes de los dos puntos ":" son el nombre del item del menu. Las palabras despues de los dos puntos ":" son los comandos que se ejecutaran. En este caso, en el menu verias "Buscar ayuda". El comando que se ejecutaria si presionas ese item seria /join #scripters. El formato de los commandos sigue exactamente el de los aliases. Mira la seccion Aliases para entender como se escribe un alias. Para crear un submenu, usa un punto "." Entre a un Canal .Buscar ayuda:join #kalamar .Visitar a los amigos en #latinchat:/join #latinchat .En que canal entramos?:/join $? En este caso el nombre del submenu es "Entre a un Canal" Todos los comandos que lo siguen, comenzando con un "." son parte de su submenu Para crar menus dentro de menus, solo agrega mas puntos Salones .Ayuda ..scriptersayuda:/join #yuda_scripters ..mIRC:/join #mirc ..ayuda_configuraciones:/join #ayuda_configuraciones .Otros Salones ..Visita #Mas-de-Treinta-y-Tantos:/join ##Mas-de-Treinta-y-Tantos ..Mp3's:/join #Mp3's .Salon a Entrar:/join #$$?="Ingresa al nombre del salon:"



39

Para separar items de menus, puedes usar un guion "-"en la linea siguiente de escritura. Por ejemplo: Quien es?:/whois $? - Miscelaneas .Editar Temporales:/run notepad.exe temp.txt .Decir algo: /say $? .Accion:/me $? Usuarios en .#Mas-de-Treinta-y-Tantos: /names #irchelp .#scripters: /names #scripters .Nombres en?:/names $? - Listar Salones:/list - Para usar el menu de la lista de usuarios (nicks), debes escoger un usuario (nick) antes de activar el menu con el boton derecho. Aqui hay un ejemplo simple de menu de la lista de nicknames o usuarios: Quien es?:/whois $1 - Modos .Op:/mode # +o $1 .Deop:/mode # -o $1 .Kick, Ban:/kick # $1 | /ban $1 - DCC Send:/dcc send $1 DCC Chat:/dcc chat $1 - Golpe:/me Golpea $1 con una silla en la nuca Privado (query):/query $1 Hola! Estas ahi...? Si quieres que un item de menu realica varios comandos, puedes usar los parentesis de llave { }. Estudia la seccion de Aliases para mas informacion sobre como usarlos. Galleta { if ($1 == $me) echo Me regalo una galleta! else echo Le doy una galleta a $1 ! }



40

El menu anterior puede ser utilizado en la lista de nicknames. El $1 se refiere al nickname del usuario que has elegido de la lista. En este caso, el mira a ver si he escogido mi propio nickname; si es asi, manda el primer mensaje, si no, manda el segundo. Los popups para los Query/Chat(privados) y la barra de menus(Menubar) funcionan igual. Identificadores y Variables Si hay variables o identificadores en el titulo de un menu, este se evaluara cada vez que el menu aparece. Esto te permite crear un menu que varia en apariencia. Si el menu entero es evaluado a $null el menu no aparece. Scripts remotos Puedes poner definiciones de menus en tu remotes usando el prefijo menu menu status { Server .Links:/links .Lusers:/lusers .Motd:/motd .Time:/time } Esta definicion agregaria un submenu a tu ventana de estado(status). La cual no aparecera en la lista de Popus programados en la ventana de estado. Tambien puedes especificar channel(salon), query/chat, nicklist(lista de nicks) y menubar como el nombre del menu y te sale en esas ventana, de la misma forma que en el ejemplo anterior de la ventana de status. menu nicklist { Slap .Haddock:/me prods $1 with a haddock } Esto te agregaria un submenu a el menu de la lista de nombres. Tambien puedes especificar menus para ventanas especiales especificando el nombre de la ventana. menu @test { dclick /command <menuitems> }



41

El "dclick" te permite especificar un comando que se activara cuando hagas dobleclick en la ventana especial (en la lista de nombres) Tambien puedes poner $1 para referirte a un nick en especial. Tambien puedes especificar multiples nombres de ventana para un solo menu,por ejemplo: menu @dogs,@cats,@goats { <menuitems> }

El mIRC permite también la creación de popups o menús personalizados; cada opción que diseñamos para estos menús ejecutará las órdenes, alias, comandos,...etc. que les introduzcamos, y podrá así mismo hacer uso de identificadores, variables,...etc. Disponemos inicialmente de 5 menús que podemos diseñar a muestro gusto con las opciones que deseemos: MENUBAR: Es el cuarto(4) menú de la barra principal de menús que se encuentraen la parte superior de la pantalla del mIRC. CHANNEL: Es el menú emergente que aparece al pulsar con el botón derecho del ratón sobre la pantalla del salon en que te ecuentras activo. NICKNAME LIST: Es el menú emergente de la lista de nicks del salon. STATUS: Es el menú emergente de la ventana de Status(Estado) del mIRC. QUERY/CHAT Es el menú emergente de la ventana de querys y de DCC chat.

Accederemos al código que genera los popups desde el menú Herramientas opción "popups". En la ventana que nos aparece tenemos a su vez una barra superior de opciones, si pulsamos "ver" podremos elegir, de entre los 5 anteriores aquel popup del que queremos ver su programacion. Ahí podremos crearlos, modificarlos o eliminarlos. Terminado el trabajo pulsaremos OK, y desde ese momento ya podremos hacer uso de las modificaciones introducidas, ya que estas quedaran grabadas.



42

La mejor forma de comprender lo popups es observando el código de los ya existentes, cada línea de este código suele corresponder con una opción del menú, veamos un ejemplo: Salones .Entrar a #yuda_scripters: /join #yuda_scripters .Entrar a #programación: /join #programación .- .Elegir salon: /join #$$?="Ingresa el nombre del salon" .Cambiar modos de salon. .Solo op’s cambian topic: /mode # +t. .No mensajes externos: /mode # +n. .Cambiar el Topic: /topic # $$?="Introduce nuevo topic" Nicks: /nick $$?="Introduce nuevo nick"

Como se puede observar cada línea describe en primer lugar el nombre de la opción de menú con la que aparecerá cuando se despliegue este. Como es sabido cada opción de menú puede tener a su vez otras subopciones, y estas a su vez otras tantas, y así sucesivamente; esto se especifica en el diseño del menú mediante los puntos que preceden a cada una de las líneas. Las líneas sin puntos delante son opciones principales que aparecerán nada más desplegarse el menú. Si tienen un punto delante significará que son subopciones de las anteriores, y se desplegarán al pulsar sobre aquella inmediatamente anterior que no tenga punto; si tienen dos puntos serán una subopción de la inmediatamente anterior que solo tuviese uno... y así sucesivamente. En virtud de lo anterior una línea de opción de un popup deberá de tener su

nombre (el que queramos) seguido de dos puntos ":" seguido de la acción o comando que se ejecutará al hacer click sobre esta opción. Si solo está el nombre, no hay dos pontos y luego un comando, es porque al seleccionarla se desplegará un submenú, así pues deberá de estar seguida de otras líneas de opciones de rango inferior , es decir, con más puntos que ella por delante, que serán las que se desplieguen al seleccionarla. Opcionalmente podemos poner tan solo un guión en lugar del nombre de una opción, esto lo único que hará será insertar una línea de separación en la lista de opciones del menú.



43

Así pues, en el ejemplo anterior, al desplegar el popup observaremos tan solo dos opciones: Salones y Nicks. Si pulsamos la segunda podremos cambiar nuestro nick introduciendo uno nuevo en la ventana que se nos presentará; en cambio, al pulsar la primera se desplegarán a su vez otras cuatro opciones, separadas las dos primeras, por una línea horizontal, de las dos últimas. De estas cuatro las tres primeras ejecutarán ya una acción cada una, sin embargo la cuarta desplegará otras tres nuevas opciones. Este razonamiento quizás pueda parecer complejo en principio, pero con un mínimo de práctica y observación descubrirá que domina las sutilezas de los popups mucho antes que cualquiera de las otras áreas de creación de script para el mIRC. Todo lo dicho para la definición de alias es también válido para construir la definición de opciones de menús, incluido el uso de identificadores. Algunos identificadores (palabras especiales con el símbolo $ delante) cobran un valor especial cuando se usan en un determinado popup; por ejemplo, el identificador posicional $1, cuando se usa en una opción del popup de QUERY/CHAT, se cargará automáticamente con el nick del la persona con la que tenemos abierto el query o DCC Chat; y en el menú NICKNAME LIST con el primer nick que tengamos seleccionado en la lista. Recuerde, para dominar los popups lo mejor es un mínimo de práctica y observar otros que ya están hechos, el mIRC dispone de algunos, y además son muchos los scripts en circulación que nos proporcionarán excelentes ejemplos de la creación y ordenación de esta excelente herramienta. Por ultimo, recuerde que es muy importante, debido a la similitud e interraleción que tienen, que usted haya leído y estudiado los Alias y sus comandos. Esto le ahorrara muchisimo tiempo y podrá entender mucho mejor lo que esta ocurriendo, sin llegar a sentir la sensación de frustración que provoca el nulo entendimiento de los protocolos de programación.



44

Remotes Los Remotos te permiten crear scripts que reaccionen a los eventos provenientes del servidor IRC, como por ejemplo cuando un usuario imgresa a un salon y te envia un mensaje. Esta herramienta es la parte mas compleja del mIRC y para poder usarla tu debes saber de antemano como funcionan los comandos del IRC, como crear Aliases, y como usar las Variables y los Identificadores. Los remotos cuentan de tres secciones distintas: 1- La seccion del Usuario, donde las direcciones de los usuarios y sus niveles de acceso se encuentran listadas. Cada usuario de tu "seccion de usuarios" puede tener asignado uno o mas niveles. Estos niveles de acceso dictaminan a que eventos el usuario tendra acceso. 2- La seccion Variables, donde las variables exustentes estaran listadas. 3- La seccion Script, donde se encuantra el script que tu vayas creando. Tu puedes cargar multiples scripts que funcionan independientes unos de otros. Esto significa que una sola accion del servidor IRC, puede dispara acciones en ino o mas scripts. Scripts consisten en eventos que solo pueden ser activados dependiendo del nivel de acceso que tenga el usuario. Tambien puedes incluir alias en tu script utilizando los prefijos de alias, y tambien incluir menuen tu script usando los pefijos de menu. Es importante que lea sobre los niveles de acceso a usuarios ya que estos son muy importantes en los remotos. Tambien debes estudiar los comandos de los remotos, identificadores y la lista interna de direcciones. Todos los siguientes eventos utilizan el mismo formato general excepto los eventos CTCP y RAWs. Abajo encontraras una lista de los eventos mas utilizados. Action FileRcvd Notice ServerOp Ban FileSent Notify ServOpen Chat GetFail Op SNotice ChatClose Input Part Start ChatOpen Invite QueryClose Text Connect Join QueryOpen Topic Ctcp Kick Quit UnBan CtcpReply Load Raw Unotify DeOp MidiEnd Send Fail



45

UserMode DeVoice Mode Serv Voice Dns Nick Wallops ServerClose Error NoSound ServerMode Note: Nunca cargues un Script que no entiendas o no sepas su funcionamiento.



46

Variables El uso de variables es el recurso fundamental en programación. Podemos ver una variable informática como un recipiente en el que podemos depositar un valor cualquiera, para después hacer uso de él dentro de una instrucción, de esta forma no será necesario tocar la instrucción cada vez que queremos alterar el valor a manejar, sino tan solo asignar antes un nuevo valor a la variable. Técnicamente una variable no es más que un espacio de nuestra memoria RAM que queda reservado en el momento en que se crea la variable, e identificado temporalmente con el nombre de esta. Cada vez que asignamos un valor a la variable el programa lo único que hace es depositar ese valor en la dirección reservada. Más adelante, cuando ejecutemos una instrucción que contenga esa variable, el programa irá a ese espacio de memoria y extraerá el valor que contenga, poniéndolo en el lugar del nombre de la variable, dentro de la instrucción en cuestión. Por ejemplo, si en un script para mIRC hemos creado una variable llamada %num, a la que hemos asignado el número 3,14159, podemos tener una instrucción como la siguiente: echo -a El valor asignado es: %num Esta orden presentará en la ventana activa un mensaje que diga: "El valor asignado es: 3,14159" Si queremos que el valor que nos presente el mensaje sea diferente, no tenemos más que asignar previamente un valor distinto a la variable. Como se ve el uso de las variables es muy sencillo. En mIRC lo único que hace falta es identificarlas con un nombre de nuestra elección y precederlo del símbolo: %. Pero, ¿Como creamos las variables y les asignamos valores?. El entorno del mIRC provee una manera muy simple de hacerlo mediante el uso de la orden /set, cuya sintaxis es la siguiente: set <%variable> [valor] Por ejemplo: set %num 3,14159



47

Es decir, es posible crear la variable en el mismo momento que le asignamos un valor. Si no especificamos valor la variable se creará, pero no contendrá nada de momento; y si usamos esta orden sobre una variable que ya existe, esta recibirá el nuevo valor especificado. En el mIRC no es necesario preocuparse de qué tipo es la información que depositamos dentro de la variable, es decir, si se trata de una cadena de caracteres, un número entero, o un número con parte entera y parte decimal. Esta distinción la hace el programa en el momento que hagamos uso de ella; en principio todas las variables se consideran como una simple cadena de caracteres, pero si empleamos para manejarlas operadores aritméticos, el programa las transforma internamente en el valor numérico que corresponde; la única limitación en este caso es que solo se tendrán en cuenta los cinco primeros valores decimales, es decir, los cinco primeros dígitos tras la coma decimal. RECURSOS DE ASIGNACIÓN: Asignar valores a una variable se puede hacer de forma directa, como hemos visto, o de forma indirecta a través de algún recurso del programa. Por ejemplo, si queremos que la variable %MiNick reciba el nick que estamos utilizando en ese momento, sin tener que especificárselo nosotros, podemos recurrir a la función $me, que nos devuelve precisamente nuestro nick actual. La asignación sería pues: set %MiNick $me Otro ejemplo, queremos asignar a una variable el contenido de otra variable: set %var2 %var1 Incluso podemos hacer que el programa nos pregunte qué valor queremos que reciba determinada variable, cuando el script llegue a ese punto; no hay mas que hacer uso del identificador $$?, por ejemplo: set %variable $$?="Asigna un valor a la variable:" Así mismo es posible también hacer que una variable reciba directamente el resultado de operaciones aritméticas sencillas: %x = 5 + 1 Suma %x = 5 - %y Resta %x = %x * 2 Producto %x = %z / $2 División %x = $1 % %valor Módulo (Resto de la división: $1 entre %valor) %x = 2 ^ %w Potencia



48

Solo es posible asignar el resultado de operaciones simples, para el uso de operaciones más complicada es preciso recurrir a la función $calc que podemos ver en el capítulo IDENTIFICADORES. Finalmente, podemos hacer incrementos o decrecimientos automáticos del valor numérico de una variable con las órdenes: inc <%variable> [incremento] dec <%variable> [decremento] Estas órdenes incrementarán o decrementarán el contenido de una variable en una cantidad especificada. Si no se especifica cantidad el incremento o decremento se hará en la unidad. Por ejemplo: set %valor 5 set %cifra 2 dec %valor %cifra echo -a El valor actual es: %valor

En la pantalla aparecerá el mensaje: "El valor actual es: 3" Si en algún momento hacemos uso de una variable que aún no ha sido creada, o bien, que no contiene ningún valor, está devolverá el parámetro $null (nulo), esto solo será útil en las comparaciones de tipo if que se estudian en su correspondiente apartado. NOTA: podemos consultar todas las variables existentes en un momento determinado, así como el valor que contienen (alterándolo manualmente si lo deseamos) desde el menú Herramientas, en la opción "Remote...", en la solapa "Variables". ELIMINACIÓN DE VARIABLES Eventualmente es posible también eliminar la variable, es decir, hacer que desaparezca la reserva de memoria que la creación de esta supuso. La orden a este efecto es la siguiente: unset <%variable_1> Es posible también utilizar el carácter * para eliminar grupos de variables, por ejemplo: unset %nom* Esta orden eliminará todas las variables cuyo nombre comience por "nom". Finalmente podemos, si lo deseamos, eliminar todas la variables instaladas son la orden: unsetall



49

Identificadores Los Identificadores te devuelven un valor especifico asignado con anterioridad, por ejemplo: $time te devolvera la hora actual. Donde quiera que el mIRC encuentre un identificador en alguno de los comandos escritos por ti, lo reemplazara con el valor actual del identificador. Muchos Identificadores tambien ejecutan operaciones en las cuales tu das los datos y estos arrojan el resultado. Tambien hay Identificadores Remotos que se utilizan con los Scripts Remotos. Un identificador muy útil que se usa en combinación con $? es $!. Este nos permite recuperar el valor que hemos introducido en la ventana de diálogo, sin necesidad de tenerlo que escribir de nuevo. Por ejemplo:

/MiNick {

/nick $?="Introduce tu nuevo nick"

/say ¿Que te parece mi nuevo nick: $! ?

}

Los Identificadores que no pueden ser evaluados o que no cuentan con toda la informacion necesari devolveran el valor $null. El valor $null puede ser utilizado como agente de comparacion junto con el if-then-else. Para todos los siguientes Identificadores, tu puedes agregarle mas Identificadores o variables encerradas en parentesis (brackets). Los Identificadores que te presentare estan listados de acuerdo a grupos de uso: IDENTIFICADORES CUSTOMS (O A LA MEDIDA) Un identificador custom es un alias que te regresa un valor, y puedes usar ese alias con el prefijo de identificador Por ejemplo, crea un alias /suma como este: suma { %x = $1 + $2 return %x } Y luego usalo en un comando: //echo El total es: $suma(1,2)



50

Puedes poner la cantidad de parametros que desees a tu identificador ej. $suma(1,2,...,N) Un identificador interno de mIRC con el mismo nombre tendra prioridad Puedes agregar aliases a los scripts de remotos(en un remote.ini, por ejemplo) usando el prefijo alias y metiendo tu alias como siempre alias suma { %x = $1 + $2 return %x } Este es el mismo identificador de arriba, pero con el prefijo alias Teclas de funcion (f1-f12) Puedes definir las teclas de funcion para que realicen ciertos comandos, como si fueran alias. Por ejemplo: /F1 /say Hola! /sF2 /query $1 /cF3 /ctcp $1 version Los prefijos s (shift) y c (Ctrl) se refieren a la tecla de mayuscula y de control respectivamente Nota: Un tecla de funcion se comportara de distintas maneras dependiendo de la ventana en que se use. Por ejemplo, si la usas en una ventana de query (privado), el parametro $1 se refiere al nickname de el usuario seleccionado. Si estas en una canal y la lista de nicknames esta activa entonces la tecla de funcion trabajara en los nicknames seleccionados. Si la lista de nombres no esta activa, entonces la lines de funcion solo trabajara en el canal. Prefijos de comando Si estas ejecutando un comando desde la linea de comandos ( osea escribiendola en el editbox, que es donde uno normalmente escribe ), puedes forzar a mIRC a evaluar los identificadores en ese comando poniendo dos // en vez de una /. Por ejemplo: /echo Mi nickname es $me Esto daria "Mi nickname es $me" y no evaluaria $me. //echo Mi nickname es $me Esto daria "Mi nickname es fulanez" si tu nickname es fulanez, claro..



51

El entorno del mIRC provee de una serie de identificadores o funciones que devuelven automáticamente un valor para su uso en definiciones de alias, popups y eventos. Todos ellos están precedidos para su identificación por el símbolo $. Cuando el mIRC, en la ejecución de un script, encuentra uno de estos identificadores, lo sustituye por el valor que este devuelve. Es importante tener en cuenta que estos identificadores deben de ir siempre especificados entre dos espacios en blanco, de lo contrario el mIRC no los identificará como tales. A continuación se relaciona una lista con la mayoría de los identificadores que se encuentran disponibles en el mIRC.

IDENTIFICADORES DE TIEMPO Y FECHA: $ctime Devuelve el número total de segundos transcurridos desde las 0 horas de 1 de enero de 1970. $date Devuelve la fecha actual en formato: día/mes/año. $day Devuelve el nombre del actual día de la semana. $duration(nº) Devuelve el número especificado de segundos transformado al formato: semanas/días/horas/minutos/segundos. $fulldate Devuelve la fecha en formato largo, por ejemplo: Wed Jun 26 21:41:02 1996 $idle Devuelve nuestro actual tiempo idle (Este tiempo es el que devolveremos ante un requerimiento finger). $ltimer Devuelve el número del último timer activado con el comando /timer $online Devuelve el número de segundos transcurridos desde que se puso a cero el reloj contador del mIRC. $ticks Devuelve el número de ticks desde que se inició el sistema operativo. $time Devuelve la hora actual en formato horas/minutos/segundos. $timer(0) Devuelve el número de timers activos en el momento actual. $timer(n°) Devuelve todas las propiedades de timer cuyo número se especifica, n°: comando, tiempo, repeticiones, retardo y tipo. $timer(nº).com Devuelve el comando asociado al timer especificado, n°. $timer(nº).type Devuelve el status del timer especificado, n°: online/offline $timer(n°) Devuelve el id del timer que se encuentra primero en la lista de timers $timestamp Devuelve el timer actual en formato: [xx:xx] $timezone Devuelve tu actual hora (de tu Zona Horaria) expresada en segundos. Para un ambiente de 16bit la devolucion dependera del ambiente de la variable TZ.



52

IDENTIFICADORES DE NÚMEROS Y TEXTOS $abs(nº) Devuelve el valor absoluto de un número (elimina el signo), por ejemplo : $abs(5) Devuelve el numero 5 $abs(-1) Devuelve el numero 1 sin signo $asc(C) Devuelve el número ASCII del carácter C. $asc(A) devuelve el numero 65 $asc(*) Devuelve el numero 42 $calc(operaciones) Devuelve el resultado de las operaciones especificadas. Por ejemplo: $calc(3.14159 * (2 ^ %x % 3) - ($ticks / (10000 + 1))) $chr(nº) Devuelve el carácter ASCII correspondiente al número especificado. Por ejemplo: $chr(65) Devolverá el carácter A $count(cadena_1,cadena_2) Devuelve el número de veces que cadena_2 se encuentra repetida dentro de cadena_1. Por ejemplo: $count (jajajajaja, ja) Devolverá: 5 $int(nº) Devuelve la parte entera de un número. Por ejemplo: $int(3,14159) Devolverá: 3 $left(cadena,N) Devuelve los N primeros caracteres de una cadena de izquierda a derecha, por ejemplo: $left(goodbye,4) Devolverá: good $right(cadena,N) Devuelve los N últimos caracteres de una cadena de derecha a izquierda, por ejemplo: $right(othello,5) Devolverá: hello $len(cadena) Devuelve el número de caracteres de una cadena. $lower(texto) Devuelve todos los caracteres de una cadena convertidos a minúsculas, por ejemplo: $lower(HOLA) Devolverá: "hola" $mid(cadena,posición,número) Devuelve el número especificado de caracteres de una cadena desde una posición dada. Por ejemplo: $mid(othello,3,4) Devolverá: "hell" $pos(cadena,sub_cadena) Devuelve la posición en que una sub_cadena comienza dentro de una cadena. Por ejemplo: $pos(hello,el) Devolverá: 2 o por ejemplo: $pos(hello,la) Devolverá: $null, ya que no se encuentra la en lo dado. Lo que se encuentra despues de la coma es lo que se pide identificar. $rand(v1,v2) Devuelve un número o letra aleatorio comprendido en el rango [v1-v2] . Por ejemplo: $rand(1,4) Devolverá cualquier número entre 1 y 4, ambos inclusive. $remove(cadena,sub_cadena) Devuelve la primera cadena, de la que habrá suprimido la primera ocurrencia expresada en sub_cadena. Por ejemplo: $remove(abcdefg,cd) Devolverá: abefg (¡¡mas claro hecharle agua!!)



53

$replace(texto,cadena,reemplazo) Busca una cadena dentro de un texto, y la reemplaza por otra especificada. Por ejemplo: $replace(abcdefg,cd,xyz) Devolverá: abxyzefg $round(número,D) Devuelve un número especificado, con solo los dos(2) primeros decimales. Por ejemplo: $round(3.14159,2) Devolverá: 3.14 $strip(texto) Devuelve un texto del que eliminará los colores, negrita y subrayado. $str(texto,N) Devuelve un texto dado repetido N veces. $str(ho,3) Devolverá: "hohoho", bueno para flood!!!! $longip Convierte una direccion IP en un valor largo o viceversa. Por ejemplo: $longip(158.152.50.239) Entregara 2660774639, o $longip(2660774639) nos dara 158.152.50.239 $upper(text) Devuelve el texto en mayusculas, por ejemplo: $upper(hello) mostrara HELLO IDENTIFICADORES DE ARCHIVOS(FICHEROS) Y DIRECTORIOS

$alias(N) Devuelve el nombre del N fichero de alias cargado en ese momento. $alias (nombre_fichero) Devuelve $null si el fichero de alias no está cargado en ese momento. Ejemplos: $alias(0) Devuelve el número de ficheros de alias cargados en ese momento. $alias(2) Devuelve el nombre del segundo fichero de alias cargado en ese momento. $alias(fiambre.txt) Devuelve $null si el fichero de alias no está cargado, o "fiambre.txt" si se encuentra cargado. $dir y $file Presentan un cuadro de dialogo desde el que permiten seleccionar un fichero para ser utilizado dentro de la especificación de un alias. $dir presenta un dialogo desde donde se puede acceder a toda la estructura de ficheros, mientras que $file presenta solo los ficheros contenidos dentro de un determinado directorio. En ambos casos se puede especificar mediante el comodín * qué tipos de ficheros se desea que aparezcan. El formato de ambos es: $dir[="Texto"] <path y nombre de fichero> $file[="Texto"] <path y nombre de fichero> Por ejemplo, podemos definir una opción de popups que reproduzca los fichero de tipo midi de un directorio llamado "midis": Música/splay $file="Selecciona la música" c:\midis\*.mid Nota: no usar estos especificadores para seleccionar un fichero a enviar por DCC, puesto que este comando lleva ya incorporado su propio dialogo de selección. $exists(fichero) Devuelve $true si el fichero existe, y $false si no es así. $exists(c:\mirc\mirc.exe) Devolverá $true o $false.



54

$findfile(directorio, tipo_de_fichero, número) Busca en el directorio especificado (y en todos sus subdirectorios), a todos los ficheros de un determinado tipo, y presenta el path y el nombre del que tiene el número de orden indicado. Si el número es 0 presentará toda la lista de ficheros encontrados de ese tipo. Por ejemplo: $findfile(c:\mirc,*.exe,1) Devolverá: c:\mirc\mirc.exe $findfile(c:\, auto*.*,1) Devolverá: c:\autoexec.bat $getdir Devuelve el directorio que tengamos especificado en el diálogo DCC options, como destino por defecto para las recepciones DCC. $getdir(tipo_fichero) Devuelve el directorio que tengamos especificado en el diálogo DCC options, como destino para las recepciones DCC de ficheros del tipo especificado. Por ejemplo: $getdir(*.txt) $lines(filename) Devuelve el número de líneas que tiene un fichero de texto. $lines(c:\irc\kicks.txt) Devolverá el número de filas del fichero: c:\irc\kicks.txt $lof(fichero) Devuelve el tamaño en bytes de un fichero especificado. $logdir Devuelve el directorio especificado en la sección Loggin del diálogo Archivo/Opciones. $mididir Devuelve el directorio especificado para los ficheros Midi en la sección Sound Requests del diálogo Archivo/Opciones. $nofile(fichero) Devuelve el path(directorio) o ruta de un fichero especificado. Por ejemplo: $nofile(c:\mirc\mirc32.exe) Devolverá: c:\mirc\ $nopath(fichero) Devuelve el nombre del fichero especificado, sin incluir el path. Por ejemplo: $nopath(c:\mirc\mirc.exe) Devolverá mirc.exe $mircdir Devuelve el path donde se encuentra actualmente el programa mIRC. $mircini Devuelve el nombre del fichero .ini principal del directorio donde se encuentra el mIRC. Este es normalmente: mirc.ini. $read Lee una línea de un fichero y la inserta dentro del alias en que se esté utilizando. Su formato es: $read [-l] [-stexto] <fichero> Ejemplos: /say $read c:\funny.txt Mostrara una línea aleatoria del fichero c:\funny.txt. /say $read -l24 c:\funny.txt Imprimirá la línea 24 del fichero. /pateo /kick # $1 $read kicks.txt Hará un kick del nick especificado dando como razón una línea elegida al azar del fichero "kicks.txt" /say $read -smirc info.txt Busca una línea dentro del fichero "info.txt" que comience por "mirc", e imprime en pantalla el resto de la línea. NOTA: si la primera línea del fichero es un número, el programa entenderá que este representa el número total de líneas del fichero, esto acelerará considerablemente la ejecución del $read.



55

$readini Lee información de un fichero .ini e inserta la fila correspondiente dentro del alias. El formato es:$readini <fichero> <sección> <item> Por ejemplo: /echo $readini mirc.ini mIRC nick Presentará nuestro nick actual tomándolo del fichero mirc.ini $script(N/fichero) Devuelve el nombre del N fichero de script cargado. Si se especifica un nombre de fichero de script en lugar de un número, devolverá este mismo nombre, o $null si dicho fichero no se encuentra cargado. Ejemplos: $script(0) Devuelve el número de ficheros de script cargados. $script(2) Devuelve el nombre del segundo fichero de script. $script(fiambre.txt) Devuelve $null si el fichero no está cargado, o fiambre.txt si se encuentra cargado. $wavedir Devuelve el directorio especificado en la sección Sound Requests del diálogo Archivo/Oopciones.

IDENTIFICADORES DE NICKS Y DIRECCIONES: $address(nick,tipo) Busca en la lista interna de direcciones la dirección asociada al nick especificado. Los tipos son los que se describen en el identificador $mask. Por ejemplo: $address(nick,1) Devuelve el formato: [email protected] Si la lista interna no contiene el nick especificado se devolverá $null. $comchan(nick,nº) Devuelve los salones en que nos encontramos nosotros junto al nick especificado. Por ejemplo: $comchan(nick,0) Devuelve todos los salones en que estamos nosotros y ese nick. $comchan(nick,1) Da el primer salon en que nos encontramos junto a ese nick $ial(máscara,nº) Devuelve direcciones de la lista interna de direcciones. Propiedades: nick, user, host, addr Ejemplos: $ial(*!*@*.demon.co.uk,0) Da todas las direcciones que concuerdan con la máscara especificada. $ial(*!*@*.demon.co.uk,3) Da la tercera dirección de la lista que concuerda con la máscara especificada. $ial(*!*@*.com,0).nick Devuelve el nick que concuerda con la máscara. $ial(*!*@*.com,4).user Devuelve el User ID que concuerda con la máscara. Para escanear todas las direcciones de la lista interna se puede usar: $ial(*,nº). $ialchan(máscara,#canal,nº) Igual al anterior pero solo referido a la lista de ocupantes de un canal especificado.



56

$level(address) Busca dentro de nuestra lista de acceso remoto el usuario con la dirección especificada y devuelve su nivel de acceso. $link(N) Devuelve el N server de las lista de servers enlazados en la actual red de IRC. Propiedades: addr, ip, level, info Ejemplos: $link(0) Devuelve el número de servers enlazados $link(1) Devuelve el primer server de la lista de links $mask(dirección,tipo) Devuelve la máscara correspondiente al tipo especificado, para una dirección dada. Por ejemplo: $mask([email protected],1) Devolverá: *!*[email protected] $mask([email protected],2) Devolverá: *!*@mardam.demon.co.uk Los tipos aplicables son los siguientes:

• 0: *!User [email protected] • 1: *!* User [email protected] • 2: *!*@host.dominio • 3: *!* User ID@*.dominio • 4: *!*@*.dominio • 5: nick! User [email protected] • 6: nick!* User [email protected] • 7: nick!*@host.dominio • 8: nick!* User ID@*.dominio • 9: nick!*@*.dominio

La utilidad de este identificador es su uso en otros identificadores y comandos. $me Devuelve nuestro actual nick. $nick(#canal,N) Devuelve el N nick de la lista de nicks del salon especificado. Si ponemos 0 devolverá en número de ocupantes del salon. $nopnick(#canal,N) Devuelve el N nick de la lista de nicks que no tiene estatus de operador del salon especificado. Si ponemos 0 devolverá en número de operadores del salon. $notify(N) Igual a los anteriores pero referido a los nicks de nuestra lista de notificaciones. $vnick(#canal,N) Igual a los anteriores pero referido a los nicks que tengan voz dentro del salon especificado $nvnick(#canal,N) Igual a los anteriores pero referido a los nicks que no tengan voz dentro del salon especificado.



57

$opnick(#canal,N) Igual los anteriores, pero referido solo a los nicks que tengan estatus de operadores en el salon. $snicks Devuelve en una línea, separados por comas, todos los nicks que tengamos seleccionados de la lista de nicks del canal.

IDENTIFICADORES DE VENTANAS $active Devuelve el nombre de la ventana activa.. $chan(N/#canal) Devuelve información sobre los salones en que nos encontramos. Propiedades: topic, mode, key, limit Si se especifica un numero en vez de un salon, devuelve el nombre de ese salon. $chan(0) Devuelve el número de salones en que nos encontramos. $chan(2) Devuelve el nombre del segundo salon en que nos encontramos. $chan(2).key Devuelve la clave del segundo salon en que nos encontramos. También podemos especificar un nombre de salon, pero solo devuelve información sobre este si nos encontramos dentro de él. $chan(#mIRC).mode Devuelve los modos del salon #mirc. $chat(N/nick) Devuelve información sobre las ventanas de DCC chat abiertas. Propiedades: ip, status Por ejemplo: $chat(2).ip Devuelve la IP del segundo DCC chat activo. $fserv(N/nick) Informa sobre las ventanas abiertas del servidor de ficheros. Propiedades: ip, status, cd (directorio abierto) $get(N/nick) Devuelve información sobre los DCC get en curso (recepción de ficheros). Propiedades: ip, status, file, size, rcvd, cps, pc Ejemplos: $get(0) Devuelve el número de dcc gets en curso. $get(2) Devuelve el nick que envía el segundo DCC get activo $get(2).rcvd Devuelve el número de bytes recibidos hasta el momento en el segundo dcc get. $get(2).cps Devuelve el número de caracteres por segundo que se están recibiendo en la segunda transmisión de ficheros $get(3).pc Devuelve el porcentaje transmitido en la tercera recepción en curso. $query(N/nick) Da el nick o dirección del N query abierto.Propiedad: address Ejemplos: $query(0) Devuelve el número de querys abiertos. $query(2) Devuelve el nick del segundo query. $query(1).address Devuelve la dirección del primer query. $send(N/nick) Devuelve información sobre los envíos de ficheros en curso (DCC sends).



58

Propiedades: ip, status, file, size, sent, cps, pc Ejemplos: $send(0) Devuelve el número de ficheros que se están enviando. $send(2) Devuelve el nick de destino del segundo envío. $send(1).sent Devuelve el número de bytes enviados en el primer DCC en curso. $send(3).pc Devuelve el porcentaje transferido en el tercer envío en curso. $send(3).status Devuelve el estado (activo, inactivo, o en espera) del tercer send en curso.

IDENTIFICADORES DIVERSOS $away Devuelve el valor $true (verdadero) o $false (falso) Si estamos away o no. $cb Devuelve los primeros 256 caracteres contenidos en el portapapeles. $cr Devuelve el carácter de retorno de carro. Es equivalente a poner: $chr(13) $editbox(window) Da texto contenido en caja de edición de determinada ventana. $email Devuelve la dirección de mail especificada en la correspondiente casilla del dialogo Archivo/Opciones. $host Devuelve el nombre del actual Local host. $ignore(N) Devuelve la dirección del N elemento de la lista de ignores. Propiedades: type $ignore(0) Devuelve el número de elementos incluidos en la lista de ignores. $ignore(1) Devuelve la dirección del primer elemento de la lista de ignores. $ignore(2).type Devuelve el flag del segundo elemento de la lista de ignores. $inmidi Devuelve $true si se está reproduciendo un fichero midi, de lo contrario devuelve $false. $ip Devuelve nuestra dirección IP. $lf Devuelve el carácter de salto de línea. Equivale a: $chr(10). $port Devuelve el número del puerto del server en el que estamos conectados. $server Devuelve el nombre del server al que estamos conectados, o $null si estamos desconectados. $server(N) Devuelve la dirección del N server de la lista de servers de Archivos/Opciones/IRC Server. Propiedades: desc (descripción), port (puerto), group (grupo) $server(0) Devuelve el número de servers de la lista. $server(2) Devuelve la dirección del segundo server. $server(2).desc Devuelve la descripción del segundo server. $server(3).port Devuelve el puerto de conexión especificado para el tercer server. $url Devuelve la dirección URL de la página actualmente cargada en el navegador. Ejemplo: /say Estoy viendo la página: $url ... se las recomiendo!



59

$usermode Devuelve nuestros actuales modos de usuario. $version Devuelve la versión del mIRC en uso. $+ Este identificador insertado en una línea de instrucción eliminará el espacio el espacio en blanco que se encuentra a su derecha, y el que se encuentra a su izquierda. $nº- Se puede usar $1 $2 ... $N para referirse a los parámetros o palabras individuales de una línea de comando. Además es posible especificar $nº- para referirse al parámetro o palabra de la posición especificada, y todos los que le siguen, y $nº_1-n_2º para referirse a todas la palabras comprendidas entre dos posiciones especificadas $address Devuelve la dirección de un usuario asociado a un evento, en la forma: [email protected]. $fulladdress Devuelve la dirección de un usuario asociado a un evento, en la forma: [email protected]. $group(N/#nombre) Devuelve el nombre o estatus de un grupo de un script. Propiedades: status $group(0) Devuelve el número de grupos del script. $group(1) Devuelve el nombre del primer grupo del script. $group(1).status Devuelve el estatus del primer grupo: on o off. $group(#name) Devuelve el estatus del grupo #name $maddress(máscara) Busca el la lista interna de usuarios y devuelve la dirección del primer usuario que corresponde con la máscara especificada $nick Devuelve el nick de un usuario asociado a un evento. $ulevel Devuelve el nivel de acceso remoto de un usuario asociado a un evento.



60

EVENTOS Estándar INTRODUCCIÓN Se conocen como EVENTOS, en informática, todos aquellos sucesos que se producen a lo largo de una sesión de trabajo de un programa, y que éste es capaz de detectar y controlar. La programación orientada a eventos es aquella en la que podemos definir previamente las acciones que el programa debe de emprender en el momento en que se produzca un evento concreto. Es decir, predisponemos al programa a que preste especial atención a algunos sucesos, y le obligamos a que analice dichos eventos a fin de determinar si se reúnen las circunstancias que hemos establecido, y de ser así, a ejecutar las acciones que para ese caso le hemos programado. El mIRC es un programa altamente configuráble y personalizáble a través de la definición de Alias, Popups, y Remotes. Dentro de este último grupo provee una de sus herramientas más potentes: la posibilidad de programar acciones orientadas a un grupo de eventos propios de una sesión de IRC; es decir, es posible programar de modo sencillo acciones de cierta complejidad como respuesta a algunas situaciones. Existen tres tipos de eventos en el mIRC, los que llamaremos estándar, que son los que se describen aquí, y los eventos CTCP que describiré en un capítulo aparte, y los eventos RAW que se explicarán en el apartado Números Raw. UN EJEMPLO DEL USO DE EVENTOS Por ejemplo, es muy sencillo hacer que el programa detecte cada vez que, en cualquier canal en el que estemos, alguien escriba nuestro nick (supongamos que es PorotoMan), y en consecuencia, si lo deseamos, comunicar privadamente a esa persona que no estamos prestando atención en ese momento. No habría más que recurrir al evento "onTEXT", quizás el más importante de todos. Para esto debemos de ir al menú "Herramientas" que se encuentra en la barra de menús de la parte superior de la pantalla y pulsar la opción "REMOTE...". Nos aparece un cuadro con una gran ventana de texto y una nueva barra de menús en la parte superior. Vayamos al menú "VER" y seleccionemos la opción "events"; ya podemos escribir en el cuadro de texto nuestras órdenes para el control de eventos



61

(hágalo a ser posible al principio de esta caja de texto). Escribiremos la siguiente línea: on 1:TEXT:Somatic:#: notice $nick Perdona $nick no estoy prestando atención!!!. Pulsamos el botón "OK" y trabajo concluido. Desde este momento, si Choclo menciona el nombre de PorotoMan recibirá un mensaje que solo podrá ver él (notice), en el que le decimos: "Perdona Choclo no estoy prestando atención!!!". Al margen de la sintaxis de la línea, que veremos más adelante, la objeción es evidente: ¿Y que pasa si SÍ estamos prestando atención? ¿tenemos que ir otra ver a la ventana de edición de eventos y borrar lo que pusimos?. Bueno, es una posibilidad, pero afortunadamente también tenemos la facilidad de hacer que la acción de los eventos que deseemos se active y desactive a nuestra voluntad. Vayamos de nuevo a la ventana de edición de eventos y escribamos lo siguiente en las líneas anterior y posterior a la que escribimos antes: #ausente off y #ausente end. El bloque total (grupo) quedará de la siguiente forma: #ausente off on 1:TEXT:PorotoMan:#:/notice $nick Perdona $nick no estoy prestando atención!!!. #ausente end

De esta forma podemos crear bloques o grupos de eventos con tantas líneas como deseemos en su interior. Para activar o desactivar su efecto debemos de incluir las instrucciones: .enable #ausente y .disable #ausente dentro de algún alias o de un menú (si esto le causa problemas ahora es el momento que estudiar a fondo las secciones de aliases y popups del mIRC ). (el punto delante de las cláusulas enable y disable tiene el único fin de inhibir el mensaje que el programa presenta en pantalla anunciando la activación o desactivación del grupo). Pruebe los efectos de la programación de eventos aplicando los distintos comandos del IRC y del mIRC en su interior (por motivos que desconozco y me superan algunos de ellos no funcionan en este contexto, como por ejemplo /me, /ame, /say, ... etc). También puede hacer uso de alias préviamenre definidos, o de la estructura IF-ELSE, pero, en cualquier caso, si desea incluir varias líneas de órdenes vinculadas a un mismo evento use siempre el separador de comandos (el carácter "|", que se obtiene pulsando las teclas ALTGR y 1 o Alt 124).



62

GENERALIDADES DE LA SINTAXIS DE EVENTOS Como ya se ha podido observar en el ejemplo anterior, lo que hemos dado en llamar un la línea de evento se forma mediante una cadena de caracteres en la que los distintos campos de información están separados por el símbolo de los dos puntos. Los campos son los siguientes: on <nivel>:<EVENTO>:<texto>:<lugar>:<comando/os> En el primer campo es necesario especificar en nivel de acceso remoto que ese usuario tiene a nuestro sistema. Este es un tema algo complejo, basta saber que este nivel es un número que marca la capacidad de acceso que cada usuario tiene para ejecutar comandos del IRC de forma remota dentro de nuestra computadora. No se alarme, nadie tendrá un nivel que usted no le haya concedido previamente, y este para los comandos que usted especifique. Para comprobar quien tiene nivel de acceso remoto a su sistema no tiene más que mirar en la solapa de "USUARIOS" de la misma ventana desde donde introducimos los eventos, ahí puede añadir o borrar lo que desee. En principio, y para todos los efectos de este documento, podemos considerar el nivel de acceso 1 que es el que otorga el programa por defecto a todos lo usuarios; por tanto, en este caso el primer campo sería: on 1. También es posible anteponer el símbolo @ antes del número de nivel, si hacemos esto, la definición del evento no se ejecutará nada más que en caso de que dispongamos del estatus de operador del canal. El segundo campo es el identificador del evento que estamos configurando, en el ejemplo anterior era TEXT, pero descubrirá que hay otros muchos. El tercer campo es el "texto", este no tiene sentido en todos los eventos, gran parte de ellos no están vinculados a texto alguno, y simplemente se omite este campo. El cuarto campo es "lugar", es decir, el salon, privado...etc. donde el mIRC vigilará la concurrencia del evento, podemos especificar de este modo que determinado evento produzca las acciones especificadas solo si se da en un determinado lugar. Como en el campo anterior no siempre tiene sentido y por tanto se omite en algunas definiciones de eventos. El último campo es el más grande, incluye el comando o comandos, alias, etc... que se ejecutarán en caso de que se produzca el evento y las circunstancias especificadas. En este campo se pueden concatenar varios comandos utilizando el símbolo "entubador": "|" (no olvide dejar espacios en blanco a ambos lados del entubador).



63

Para aumentar aun más la potencia de la configuración de eventos, estos admiten el uso de funciones, son todos aquellos identificadores que comienzan por el símbolo $ (la referencia del mIRC los llama parámetros, el tema es mas bien terminológico, yo prefiero verlas como funciones puesto que junto con las internas del programa el mIRC permite definir otras propias, con una sintaxis muy similar a la del lenguaje Cobol(por lo menos eso es lo que me dijo Jose)). No se muestra en este "Manual" una lista exhaustiva de dichas funciones, puesto que muchas de ellas son propias de un solo evento concreto, mientras que otros no las admiten. No obstante, si presta atención a los ejemplos irá viendo la forma y utilidad de la mayoría de ellas, en los lugares en los que son efectivas; el resto lo debe de aportar la experiencia personal. (las funciones deberán de tener siempre espacios en blanco a ambos lados de su nombre). Es perfectamente posible, así mismo, el empleo de variables y estructuras IF-ELSE dentro de las definiciones de eventos, encontrará numerosos ejemplos de este uso en los scripts para mIRC que circulan a libre disposición en la WWW y el IRC.

Evento ON TEXT Este evento se produce al recibirse un mensaje especificado, bien en un privado, o bien en un salon en el que nos encontramos. Formato: on <level>:TEXT:<texto>:<*><?><#[,#]>:<comandos> Ejemplo: on 1:TEXT:*ayuda*:*:/msg $nick ¿Cual es el problema?

El texto del mensaje que deseamos que produzca el evento se puede especificar de varias maneras: * El evento se producirá ante cualquier texto. & El evento se producirá ante cualquier palabra. Texto El evento se produce anta una palabra concreta y no otra.

Texto* Se produce ante una cadena de caracteres que comience por el texto especificado.

*Texto Se produce ante una cadena de caracteres que finalice por el texto especificado.

*Texto* El evento se produce si el texto contiene la cadena especificada, sea cual sea su posición.



64

Se puede especificar el lugar donde se controlará el evento de la siguiente forma:

? Controlara la producción del evento dentro de un query o de un DCC chat

# Controlara la producción del evento dentro de un salon cualquiera en el que nos encontremos

#canal_1,#canal_2,...

Controlará la producción del evento dentro de un salon especificado.

* Controla el evento en un privado o salon indistintamente. Ejemplos: on 1:TEXT:Hola*:#:/msg $chan ¡Bienvenido al salon $chan $nick $+ ! Esta instrucción detectará cuando alguien diga la palabra "Hola" en cualquier salon que nos encontremos, y automáticamente le dará la bienvenida al salon en cuestión. El identificador $+ elimina los espacios en blanco que tiene a ambos lados, de ese modo podemos hacer que el nick de la persona que ha dicho "Hola" aparezca en nuestra respuesta seguido del símbolo "!", si escribimos directamente este símbolo a continuación de $nick este no será reconocido como un identificador del nick del usuario, sino que aparecerá literalmente como está en la orden. También es posible emplear variables para dar más flexibilidad al formato del evento, por ejemplo: on 1:TEXT:%text:%salon:/msg $nick Tú has escrito %text en el salon: %channel Este ejemplo trabajará con los valores previamente guardados en las variables %text, y %salon. Nota: Este evento se producirá solo ante textos de otros usuarios, los de usted no desencadenarán el evento.

Eventos ON ACTION y ON NOTICE

Tienen el mismo formato que on TEXT, y se producen a partir de una acción o de una noticia respectivamente. Recordemos que una noticia se produce cuando alguien nos envía un mensaje con el comando /notice, y una acción cuando alguien efectúa una acción de control dentro del canal; por ejemplo: on 1:ACTION:*set mode*:#:/msg $chan ¡Ya estamos jugando con los modos!



65

Esta orden detectará cualquier acción que contenga la cadena "Set mode", y emitirá un mensaje al canal en que se produce. on 1:NOTICE:*:?:/msg $nick Estoy ocupado, espera un momento! Esta orden detecta cualquier /notice recibido estando en un privado, y responde con otro /notice al autor.

Eventos ON BAN y ON UNBAN

Estos eventos se producirán cuando un usuario sea baneado o desbaneado en el canal. Formato: on <level>:BAN:<#[,#]>:<comandos> Ejemplos: on 1:BAN:#:/msg $nick Has sido baneado de: $chan on 9:BAN:#:/mode $chan -o $nick | /mode $chan -b $banmask

El segundo ejemplo es una acción múltiple que quita el estatus de operador al usuario que puso el ban, y elimina este cuando el usuario baneado tiene nivel 9 o superior en la lista de usuarios de nuestro programa (la función $banmask devuelve la máscara de baneo que fue empleada, y se usa, en este caso, para eliminar dicho baneo). on 1:UNBAN:#:/msg $bnick Has sido desbaneado por $nick Observe en este ejemplo el uso de la función $bnick. Esta devuelve el nick del usuario baneado o desbaneado, pero solo en caso de que dicho nick este incluido dentro de la máscara del baneo. En caso contrario $bnick = $null (nulo). Es posible tener en cuenta en la sintaxis de la instrucción los niveles del baneador y del baneado. A este fin se puede preceder el número de l nivel de los signos: <,>,<=,=>,<>, ó =. Por ejemplo: on >=2:BAN:#:/msg $chan $nick baneado $banmask (legal) En esta situación, si el nivel del baneador es mayor o igual que el del usuario baneado, se comunica que este es un ban legal???? (como se podría comunicar cualquier otra cosa) Recuerde, esta sintaxis compara los niveles de baneado y baneador, nunca que este tenga o no nivel superior o igual a 2. Nota: Estos eventos solo operan cuando el server de IRC proporciona los nicks de baneador y baneado, y no cuando da sus direcciones. Observe el siguiente ejemplo:



66

on 1:BAN:#: { if ( $banmask iswm $address( $me ,0)) || ( $me isin $banmask ) { echo -s $nick te ha baneado con esta máscara: $banmask } if ( $me isop $chan ) { mode $chan -ob+b $nick $banmask $address($nick,2) } }

Esta rutina se inicia cada vez que se produce una acción de baneo en un salon en que nos encontramos. En primer lugar comprueba que la máscara del ban coincida con la nuestra o bien tiene incluido nuestro nick, en tal caso emite un mensaje a la ventana de estatus especificando la persona que lo ha realizado y la máscara con la que se ha hecho el ban, a continuación comprueba si somos operadores del canal, y en tal caso retira el estatus de operador a quien nos ha baneado, y le banea a su vez.

Eventos ON CHAT y ON SERV

Los eventos on CHAT y on SERV se producen cada vez que es enviado un mensaje la una ventana de DCC chat, o a un Fserve respectivamente. Es similar al evento on TEXT, el cual no funciona en un chat ni en un servidor de ficheros. Formato: on <level>:<CHAT/SERV>:<texto>:<comandos> Ejemplo: on 1:CHAT:*ayuda*:/msg $nick Cual es el problema?

La especificación del texto que producirá el evento se hace de la misma forma que en ON TEXT.

Eventos ON CHATOPEN y ON CHATCLOSE

Estos eventos se producen al abrirse o cerrarse (respectivamente), una sesión de DCC chat. Formato: on <level>:CHATOPEN:<comandos> Ejemplo: on 1:CHATOPEN:/msg =$nick Bienvenido!

Ejemplos: on 1:CHATOPEN:/msg =$nick Hola, estoy contigo en un momento. Esta instrucción envía una frase al DCC chat cuando este se abre por primera vez. El uso del signo "igual" delante de $nick es necesario para que el mensaje se dirija a la misma ventana del DCC chat, y no a una ventana privada aparte. on 1:CHATCLOSE:/notice $nick fin de la discusión! Esto se produce al cerrar la ventana del DCC chat.



67

Eventos ON SERVOPEN y ON SERVCLOSE

Estos eventos se producen al abrirse o cerrarse (respectivamente), una sesión del FSERVE . Formato: on <level>:CHATOPEN:<comandos> Ejemplo: on 1:CHATOPEN:/msg =$nick Bienvenido!

Eventos ON CONNECT y ON DISCONNECT

El evento on CONNECT se produce cuando mIRC conecta al server de IRC, después de visualizar el MOTD (mensaje del día del servidor). Formato: on <level>:CONNECT:<comandos> Ejemplo: on 1:CONNECT:/join #ayuda_irc

on DISCONNECT es otro evento con el mismo formato, que se produce al desconectarse del server. Ejemplo: on 1:CONNECT:/echo Conectado a $server a las $time Tu nick es: $nick

Evento ON CTCPREPLY Se produce cuando otro usuario responde a una pregunta CTCP por parte de usted. Formato: on <level>:CTCPREPLY:<texto>:<comandos> Ejemplo: on 1:CTCPREPLY:VERSION*:/echo $nick está usando IRC cliente: $1-

Ver evento on TEXT para los formatos de texto aceptados. Ejemplo: on 1:CTCPREPLY:PING*:/echo -s $nick ha respondido al ping!

Eventos ON OP y ON DEOP

Se producen cuando un usuario del canal es opeado o deopeado. Formato: on <level>:OP:<#[,#]>:<comandos> Ejemplo: on 1:OP:#ayuda_irc:/msg $nick No abuses del estatus!

El evento on SERVEROP es exactamente igual, y se produce cuando un usuario es opeado por el server. Ejemplos:



68

on 9:OP:#:/mode $chan -o $opnick | /msg $nick no opees a esa persona! En este ejemplo el evento se produce cuando es opeado un usuario de nivel de acceso 9 en nuestra sección de remotes. $opnick devuelve el nick de la persona opeada o deopeada, y $nick el de la que lo opeó o deopeó. on 1:DEOP:#ayuda_irc:/mode $chan +o $opnick Con esta orden devolvemos el op a cualquier persona que sea deopeada en el canal #ayuda_irc. Es posible tener en cuenta en la sintaxis de la instrucción los niveles del opeador y del opeado. A este fin se puede preceder el número de nivel de los signos: <,>,<=,=>,<>, ó =. Por ejemplo: on >=2:OP:#mIRC:/msg $chan $nick opeado (legal) En esta situación, si el nivel del opeador es mayor o igual que el del usuario opeado, se comunica que este es un op legal???????(como se podría comunicar cualquier otra cosa) Recuerde, esta sintaxis compara los niveles de opeado y opeador, nunca que este tenga o no nivel superior o igual a 2. Nota: Estos eventos solo operan cuando el server de IRC proporciona los nicks de opeador y opeado, y no su cuando da sus direcciones.

Eventos ON VOICE y ON DEVOICE Se produce cuando un usuario recibe o es privado de voz en un salon moderado en que nos encontramos. Formato: on <level>:VOICE:<#[,#]>:<comandos> Ejemplo: on 1:VOICE:#:/msg $vnick ya tienes voz en: $chan

Ejemplos: on 9:VOICE:#:/mode $chan -v $vnick | /msg $nick No le des Voz a esa persona! Esta orden se ejecuta cuando el que recibe voz tiene nivel 9 o superior. on 1:DEVOICE:#mIRC:/mode $chan +v $vnick Devuelve la voz al que se le quite en el canal. Son aplicables también los prefijos de comparación de niveles descritos en on BAN y on OP.



69

Evento ON DNS Se produce cuando hacemos un requerimiento DNS (comando /dns). Formato: on <level>:DNS:<commandos> Ejemplo: on 1:DNS:/notice $me resuelto: $raddress

Ejemplo: on 1:DNS:/echo $nick ip address: $iaddress named address: $naddress resolved address: $raddress

Evento ON ERROR Se produce cuando el server envía un mensaje de error, por ejemplo, en una desconexión. Formato: on <level>:ERROR:<texto>:<commandos> Ejemplo: on 1:ERROR:*server full*:/echo Has salido del server!

Ver el evento on TEXT para el formato del texto. Ejemplos: on 1:ERROR:*banned*:/echo Has sido baneado de este server!

ON FILESEND y ON FILERCVD. ON SENDFAIL y ON GETFAIL Se producen al completarse un dcc send o un dcc get (envio o recepción de ficheros reapectivamente). Formato: on <level>:FILESENT:<filename[,filename]>:<comandos> Ejemplo: on 1:FILESENT:*.txt:/msg $nick ahí te mando: $filename !!

Los eventos on SENDFAIL y on GETFAIL se producen cuando un dcc send o un dcc get son fallidos. Ejemplos: on 1:FILESENT:*.txt,*.ini:/echo Enviado $filename a $nick $address Se produce cuando enviamos un fichero .TXT o INI. $filename devuelve el nombre del fichero enviado. on 1:FILERCVD:*.txt,*.ini:/echo Recibido $filename de $nick | /run notepad.exe $filename Esta orden avisa cuando hemos recibido ficheros .TXT e .INI, y abre el bloc de notas para ver su contenido. on 1:SENDFAIL:*.txt:/echo Ha fallado el envío de $filename a $nick!!



70

Evento ON INPUT

Se produce cuando introducimos texto en una caja de texto y pulsamos INTRO. Formato: on <level>:INPUT:<commandos> Ejemplo: on 1:INPUT:/echo Texto introducido: $1-

La función $1- devuelve en este caso toda la cadena de texto introducida.

Evento ON INVITE Se produce cuando un usuario nos invita a un canal. Formato: on <level>:INVITE:<#[,#]>:<comandos> Ejemplo: on 1:INVITE:#mIRC:/join $chan

Eventos ON JOIN y ON PART

Se producen al entrar o salir un usuario de un canal en que nos encontramos Formato: on <level>:JOIN:<#[,#]>:<comandos> Ejemplo: on 1:JOIN:#:/msg $nick Hola!

Evento ON KICK Se produce cuando un usuario es expulsado de un canal en el que nos encontramos. Formato: on <level>:KICK:<#[,#]>:<comandos> Ejemplo: on 5:KICK:#:/invite $knick $chan | /msg $nick Hey, $knick ese es mi amigo!

Es aplicable también aquí la regla de comparación de niveles de los nicks descrita el los eventos on BAN y on OP.

Eventos ON LOAD y ON START

Estos eventos se producen cuando un fichero de script es cargado o descargado. Formato: on <level>:LOAD:<commandos> Ejemplo: on 1:LOAD:/echo mIRC Script cargado!



71

Eventos ON MIDIEND y ON WAVEEND

Se produce cuando el mIRC termina la reproducción de un fichero MIDI o WAV Formato: on <level>:MIDIEND:<commandos> Ejemplo: on 1:MIDIEND:/splay jazzy.mid

Este evento no tiene funciones asociadas. No se producirá si la reproducción se detiene a causa de una interrupción, solo lo hace cuando la reproducción es completada.

Evento ON MODE

Se produce cuando un usuario cambia los modos del salon (pero no los de usuario). Formato: on <level>:MODE:<#[,#]>:<comandos> Ejemplo: on 1:MODE:#ayuda_IRC:/notice $me $nick Cambia modos de $chan a: $1-

On SERVERMODE es otro evento que se produce cuando los modos son cambiados por el servidor. Ejemplo: on @1:MODE:#:/notice $me $nick changed $chan mode to $1- Esta instrucción se produce cuando alguien cambia los modos del salon teniendo nosotros también el estatus de operador.

Evento ON NICK Se produce cuando un usuario cambia de nick dentro del canal. Formato: on <level>:NICK:<commandos> Ejemplo: on 1:NICK:/msg $nick Hi $newnick!

$nick devuelve el nick antiguo; $newnick el nuevo.

Evento ON NOSOUND Este evento se produce cuando alguien activa un sonido en el canal y el mIRC no encuentra el fichero midi o wav en nuestros directorios de sonidos, los especificados en el dialogo Archivo/Opciones/Sonidos. Formato: on <level>:NOSOUND:<comandos> Ejemplo: on 1:NOSOUND:/notice $nick No tengo el fichero $filename



72

Eventos ON NOTIFY y UNOTIFY Se producen al entrar o salir del IRC un usuario que se encuentra en nuestra lista de notificaciones. Formato: on <level>:NOTIFY:<commandos> Ejemplos: on 1:NOTIFY:/msg $nick Hola nick, ya te veo venir!!! on 1:NOTIFY:/notice $me $nick se va del IRC *sniff*

Eventos ON QUERYOPEN y ON QUERYCLOSE Se producen respectivamente al abrirse una ventana de query. Formato: on <level>:QUERYOPEN:<comandos> Ejemplo: on 1:QUERYOPEN:/echo -s Abierto query con: $nick $address | / msg $nick Hola $nick

Evento ON QUIT Se produce cuando un usuario que está en nuestro salon sale del IRC. Formato: on <level>:QUIT:<commandos> Ejemplos: on 1:QUIT:/notice $me $nick sale del IRC con el mensaje: $1- on 1:QUIT:/msg $chan Nos vemos $nick Te esperamos de regreso pronto

Evento ON SNOTICE Se produce cuando recibimos una noticia del server. Formato: on <level>:SNOTICE:<texto>:<commandos> Ejemplo: on 1:SNOTICE:*client connecting*:/halt

Para una explicación del formato del texto, ver el evento on TEXT. Ejemplo: on 1:SNOTICE:*split*:/splay hack.wav Activa un fichero de sonido en caso de una noticia del server anunciando un split.



73

Evento ON TOPIC Se produce cuando algún usuario cambia el tópico del salon. Formato: on <level>:TOPIC:<#[,#]>:<comandos> Ejemplo: on 1:TOPIC:#mIRC:/msg $chan Quien te dio permiso para cambiar el Topic?: $1-

La función $1- devuelve el texto completo del nuevo tópico.

Evento ON USERMODE Se produce cuando cambiamos nuestros modos de usuario. Formato: on <level>:USERMODE:<commandos> Ejemplo: on 1:USERMODE:/echo nuevos modos: $1-

Evento ON WALLOPS Se produce cuando recibimos un wallops message. Formato: on <level>:WALLOPS:<texto>:<commandos> Ejemplo: on 1:WALLOPS:*aviso*:/echo $nick mensaje de aviso a las: $time

Ver el evento on TEXT para una explicación de los posibles formatos del texto.



74

USUARIOS REMOTOS Y EVENTOS CTCP

Introducción Las siglas CTCP significan “Client to Client Protocol” o “Protocolo de cliente a cliente”, y básicamente se trata de un tipo escpecial de comunicación entre los usuarios de un servidor de IRC que será usada para provocar que los usuarios de el script que estemos haciendo ejecuten ciertas acciones automáticamente al recibir cierta información por CTCP. Por otra parte los usuarios remotos se refiere a algo que usted seguro que ya ha visto anteriormente en el tutorial de enventos remotos, se trata de ese numerito que siempre ponemos en el evento por ejemplo “on 1:OPEN:” , ¿qué es ese ‘1’? Pues sencillamente es el nivel que necesita un usuario para hacer que salte ese evento con los comandos que se hayan especificado, despues entraré en más detalle en esto, ahora volviendo al principio vamos a ver todo lo referente a los eventos CTCP:

Comandos CTCP Para mandar información a otro usuario mediante CTCP lo haremos de la siguiente forma: /ctcp <nick> <mensaje> donde <nick> es el nick de la otra persona y <mensaje> es cualquier mensaje que queramos enviar por ese protocolo. Lógicamente no nos pondremos a hablar con un usuario mediante CTCP's ya que seria absurdo estando los dos conectados al IRC. Los CTCP's tienen otra utilidad... que es la de que el otro usuario reaccione automáticamente de una cierta manera al usted enviarle ese CTCP. Por ejemplo, existe uno que tiene el mIRC ya implementado: el famoso CTCP PING y consiste en enviar un ping al otro usuario: /ctcp <nick> ping El programa del otro usuario responderá automaticamente al CTCP PING y lo hará devolviendo una información, que al llegarnos de nuevo el mIRC nos muestra en pantalla. En este caso en pantalla se muestra el “Lag” o retardo de la línea que hay entre usted y la persona a la que envió el ping. Puede probar con los otros CTCP implementados ya en mIRC, el funcionamiento de todos es similar; solo varia la respuesta que proporcionan. A continuación aprenderá a crear sus propias respuestas a ciertos CTCP's, ya que el mIRC solo trae unas cuantas ya definidas (como son PING, VERSION, TIME ...) pero usted quizás quiera hacer otras con otros nombres, o tal vez cambiar las respuestas que a los ya existendes dará su programa.



75

Eventos CTCP Vamos a ver ya como usamos este tipo de eventos para que la explicación sea más fácil de entender. En la sección “Remotes” del editor del mIRC es donde definiremos estos eventos y se hacen de una forma parecida al resto de eventos remotos. La sintaxis es: ctcp <nivel>:<texto>:<#,?,*>:{ comandos } Este tipo de eventos haran que nuestro programa se comporte de cierta manera (es decir, que ejecute los comandos que le especifiquemos) cuando recibamos un CTCP <texto> de otro usuario. El <nivel> de momento lo dejaremos siempre en ’1’ , y el otro parámetro ha de ser o bien un ‘#’ si nos referimos a un salon, un ‘?’ para un privado(query) o un ‘*’ para “en cualquier lado”. Con un pequeño ejemplo lo veremos más claro, copie lo siguiente en el editor del mIRC, pestaña “Remotes”: ctcp 1:*hora*:*:{ msg $nick Son las $time

} Ese evento hará como ya habrá imaginado que cuando un usuario le haga un /ctcp <nick> hora , usted automáticamente le responda enviándole un query en el que diga por ejemplo “Son las 19:45:23” . Como ve se pueden usar ‘*’ en el parámetro <texto> para indicar que si la palabra “hola” del mensaje CTCP viniera precedida de cualquier otra, o despues de esa palabra hubiera alguna palabra más, se ejcutaría de todas formas en comando. En este ejemplo en concreto eso no es de mucha utlilidad, pero en el siguiente si que lo será: ctcp 1:dime*:*:{ msg $nick Lo siento estoy ocupado

} Este evento hará que cuando un usuario le envíe un /ctcp DIME , usted le responda diciendole que está ocupado. Por ejemplo un usuario le podría hacer un /ctcp <sunick> dime la hora o quizas /ctcp <sunick> dime tu nombre. En cualquier caso la respuesta será la misma. Lo que hemos visto hasta ahora se refiere a crear eventos CTCP propios, que no existían antes en el mIRC y a los que el script responderá de la forma que le hemos especificado, pero también si quisiera, podría cambiar su respuesta a algunos de los eventos CTCP ya definidos, como es el caso del PING, para ello tendremos que especificar al final de los comandos, el comando /halt , por ejemplo: ctcp 1:PING:*:{ notice $nick NO me toques, gracias! | halt

}



76

Este evento hará que cuando usted reciba un /ctcp ping de algún usuario, le enviará un /notice diciéndole: “NO me toques, gracias!”, y mediante el comando /halt haremos que el script deje de procesar ese evento, y de esa forma que no procese la parte que ya estaba hecha en el mIRC (la que nos devuelve el lag). También podríamos usar este procedimiento para otros CTCPs ya definidos como son TIME, USERINFO ... etc. Otra utilidad de estos eventos puede ser la de controlar nuestro mIRC “a distancia”, y me explico, si abrimos dos mIRCs, podremos controlar a uno de ellos mediante CTCPs mientras que el otro lo controlaremos normalmente, se pueden usar por lo tanto para controlar a nuestros clones, por ejemplo si copiamos el siguiente código en la sección Remotes y abrimos dos mIRCs : ctcp 1:habla*:#:{ /say $1- } Cuando desde uno de los mIRCs escribamos /ctcp <nick_clon> HABLA <mensaje> el otro mIRC que hemos abierto enviará el mensaje que pongamos después del “HABLA” al salin, por ejemplo si ponemos /ctcp <nickclon> habla soy un bot, me manejan con ctcps! hará que nuestro clon diga ese mensaje al salon. ctcp 1:quit:*:{ /quit $1- } Este nuevo ejemplo hará que al recibirlo el CTCP, el clon cierre el mIRC con el mensaje especificado en /ctcp <nickclon> quit <mensaje_de_quit> ctcp 1:entra:*:{ /join $1 } Este hará que el clon entre en el salon que especifiquemos en /ctcp <nickclon> entra #salon ctcp 1:cometin:#:{ /say Me llamo $1 , tengo $2 años y soy $3 } Este último hará que el clon diga en el salon ese mensaje usando las tres siguientes palabras que pongamos despues del /ctcp <nickclon> cometin, por ejemplo si ponemos /ctcp <nickbot> cometin Raul 92 alto , el bot o clon pondrá en el canal “Me llamo Raul, tengo 92 años y soy alto”. Con esto hemos matado dos pájaros de un tiro, no sólo ya sabemos manejar los eventos CTCP y como evitar las respuestas predeterminadas de algunos de ellos, sino que hemos aprendido sobre su principal utilidad que es la creación de Clones que obedezcan nuestras órdenes, tambien conocidos como “bots”.



77

Antes de pasar a la siguiente sección hay que comentar también que hay un tipo especial de eventos CTCP que sirven exclusivamente para cambiar la apariencia de las respuestas estándar de los CTCPs predefinidos en el mIRC... es decir que por ejemplo cuando usted hace un ping a alguien, ese alguien le devuelve la información del ping, y usted ve en pantalla algo como: [PorotoMan PING reply]: 0 secs Pero quizás para hacer más bonito el script le gustaría que pusiera: Lag con PorotoMan: 0 segundos Para ello usamos el evento ON CTCPREPLY que tiene la siguiente sintaxis: on 1:CTCPREPLY:<ctcp>:{ comandos } Donde <ctcp> pondremos el CTCP predefinido al que nos referimos, y en comandos la secuencia de comandos que queremos ejecutar. Generalmente para este tipo de acciones usaremos /echo para poner lineas de texto en pantalla. Vamos a ver como conseguiriamos hacer que la respuesta del PING nos fuera mostrada como hemos visto antes, debemos escribir en los “remotes”: on 1:CTCPREPLY:*PING*:{ %lag = $ctime - $2 echo –s Lag con $nick : %lag halt

} Lo que hemos hecho es primero calcular el lag basándonos en la información que nos devuelve el nick al que le hemos hecho el PING. En este caso nos devuelve: “PING 919197981” . ¿Y que es ese numero tan largo? . Ese numero corresponde a una referencia de tiempo, indicada como el numero de segundos transcurridos desde el 1 de enero de 1970 . El instante al que se refiere ese número es el momento en que la persona recibio el PING, por lo tanto si restamos a la hora actual en el formato $ctime (que nos devolvera la hora actual como numero de segundos desde el 1 de enero de 1970) de la fecha en la que el nick recibio el ctcp, nos quedará un numero más pequeño y corresponderá al LAG en segundos. Guardamos ese dato en la variable %lag y a continuacion, mediante un /echo, ponemos la información en Status, y el comando /halt. Se debe estar preguntando ¿ese halt no parará el proceso del PING y nos dejará sin ver la información? La respuesta es no, puesto que cuando este evento “salta” la información del PING ya nos ha sido devuelta por la otra persona, así que en este tipo de eventos el /halt al final lo único que hará será evitar que veamos, además del mensaje que hemos especificado, el que ya había por defecto. Pruebe ese ejemplo, y después pruebelo de nuevo suprimiendo el /halt para que vea usted mismo a que me refiero.



78

Usuarios Remotos Ya le he dado una pista antes de que son los usuarios remotos... nos referimos a un usuario remoto cada vez que especificamos un evento remoto , por ejemplo en el evento “on 1:JOIN” le estamos diciendo al mIRC “cuando un usaurio de nivel 1 entre a un canal...” . Ésta es una sección completamente opcional y no necesariamente todos los scripts harán uso de ella, puesto que sólo es realmente útil para ciertas tareas muy específicas. Antes que nada debe saber, que por defecto, nivel 1 quiere decir “todos los usuarios”, es por eso que hasta ahora todos los eventos remotos se han declarado con “on 1:...” para que tengan efecto sobre todos los usuarios, pero podría darse la ocasión en que usted quiera que algun o algunos usuarios en concreto tengan acceso a unos eventos y no lo tenga el resto, para ello les tendremos que asignar un nivel.

• Asignación de niveles a usuarios Para asignar un nivel determinado a un usuario iremos al editor del mIRC, pero esta vez a una pestaña que seguramente tendremos en blanco, la pestaña “USERS”. La sintaxis para declarar que un usuario tiene un cierto nivel es: <nivel>:<nick>!<user>@<host>/<ip> por ejemplo: 10:PorotoMan!*@* 20:Choclo!*@conmutado.ctcreuna.cl Hemos creado dos usuarios remotos, el primero PorotoMan le hemos dado el nivel ‘10’ y cualquier persona con ese nick tendrá acceso a los privilegios de ese nivel 10, que los especificaremos más adelante. El segundo nivel que hemos es asignado es más especifico porque se lo asignamos a un nick y a una máscara, es decir que el nivel 20 solo lo tendra aquel que su nick sea “Choclo” y su host sea “conmutado.ctcreuna.cl”, de esa forma nos aseguramos que los provilegios que especifiquemos para el nivel 20 solo los Choclo y no alguna persona que se ponga ese nick. Una cosa importante a recordar es que una persona con nivel 20 tendrá acceso no solo a los privilegios del nivel 20, sino también a los de nivel 19,18,17....etc, es decir que en el ejemplo anterior, Choclo tendria acceso a los eventos de nivel 20, pero tambien a los de nivel 10. Si quisieramos que Choclo tuviera acceso únicamente a los eventos de nivel 20, tendríamos que escribirlo de la siguiente forma: =20: Choclo!*@conmutado.ctcreuna.cl El ‘=’ delante del nivel indica que la persona especificada solo podra acceder a los eventos que marquemos con un nivel 20, es decir que los de nivel 1, o 2, o 10 no los podrá acceder el usuario Choclo.



79

Pues bien así se asignan los niveles de una forma “estática” es decir, vamos al editor del mIRC y los intriducimos a mano, pero tambien podríamos hacerlo de una forma “dinámica” mediante comandos del mIRC, digo dinámica porque nos pueden servir estos comandos para más adelante permitir al usuario cambiar el nivel de cierta persona o añadir mas gente con un determinado nivel. Los comandos son: /auser [-a] <niveles> <nick/host> Añade un usuario con el nivel o niveles que especifiquemos a la lista de usuarios remotos, si especificamos el parámetro [-a] hará que si el usuario ya existía, se le añada el nuevo nivel al que ya tenía. Por ejemplo: /auser 10 PorotoMan Añade a PorotoMan a la lista de usuarios remotos con nivel 10, si PorotoMan ya estaba en esa lista, será borrado y sustituido por la nueva entrada. /auser –a 12,13 PorotoMan Añade los niveles 12 y 13 a los que ya tenía el usuario PorotoMan, por lo tanto la sección users quedará asi: 10,12,13: PorotoMan En lugar de un nick podriamos haber especificado una máscara con el modelo nick!user@host /flush [niveles] Este comando borrará a todos los nicks de niveles especificados que no estén actualmente en ninguno de nuestros canales. Por ejemplo: /flush 1,2,3 . Borrará de a lista de usuarios remotos a todas las personas que tengan nivel 1,2 o 3 y no estén en ninguno de nuestros canales. /flush Cuando se especifique este comando sin argumentos borrará todas las entradas (en la pestaña “Users” del mIRC) de gente que no esté actualmente en ninguno de nuestros canales /guser [-a] <niveles> <nick> [tipo] Este comando trabaja de la misma forma que /auser con la única diferencia de que solo le podemos especificar el nick de la persona y el mIRC mirará su máscara actual y la añadirá al nick, para ello tenemos que especificarle también el [tipo] de máscara que será un número de 0 a 9 /guser 10 TipoX 4 Añade al nick TipoX con nivel 10 y una máscara del tipo 4 (*!*@*.dominio)



80

/ruser [niveles] <nick / host> [tipo] Borrará los niveles que especifiquemos del nick o host que especifiquemos, podemos tambien darle solo el nick y especificar el [tipo] de máscara para que el mIRC la mire y borre los niveles de los usuarios que tengan esa máscara. /ruser 10 Poroto Borrará el nivel 10 que le hayamos dado al nick Ytreme /ruser Poroto Borrará a Ytreme de la lista de usuarios remotos (o lo que es lo mismo le quitará todos los niveles) /ruser 25 Poroto 4 El mIRC buscará la información de Poroto y borrará el nivel 25 de todas las entradas en la lista de usuarios remotos que tengan esa máscara. /rlevel [-r] <niveles> Borra a todos los usuarios de la lista de usuarios remotos cuyo primer nivel sea el que especifiquemos en <niveles>. Si usamos el parámetro [-r] borrará a todos los usuarios que tengan el nivel <niveles> en cualquier lugar. Partiendo de: 10,12,15: Coronta 12,20: Poroto El comando: /rlevel 12 borrará al usuario Coronta puesto que su primer nivel el 12 /rlevel –r 12 Borrará tanto a Coronta como a Poroto puesto que tienen el nivel 12 , no importa en que posición /ulist [ < / > ] <nivel> Lista a los usuarios de nivel <nivel> , o bien podemos especificar el parámetro [ < / > ] como “>4” o “<10” . Por ejemplo: /ulist >10 Lista todos los usuarios cuyo nivel sea menor o igual a 10 /ulist >20 Lista a todos los usuarios remotos cuyo nivel sea mayor o igual a 20 Restricciones en el acceso a Eventos Vista ya la forma en la que asignamos niveles a usuarios, ahora veremos como puede hacer que ciertos eventos solo sean accesibles por usuarios especificos (con un nivel especifico), para ello simplemente cambiaremos ese “1” que soliamos poner en todos los eventos remotos/ctcps por el nivel mínimo que necesitará el usuario para acceder al evento: on 10:JOIN:#:{ echo –s Ha entrado un usuario de nivel 10 o superior}



81

Este evento hará que cuando un usuario de nivel 10 o superior entre en un canal en el que usted esté, le salga un mensaje en en Status avisándole. Pero recuerde que este evento no sólo lo accederan los usuarios de nivel 10, sino los de 20, 30, etc... Pero también podemos hacer que un evento solo sea accesible por los usuarios de un nivel determinado, y no por aquellos usuarios que tengan más nivel, lo haremos mediante el prefijo ‘+’ : on +5:JOIN:#:{ echo –s Ha entrado un usario de nivel 5 } De esta forma si entra un usuario con nivel 10 por ejemplo, este evento no se ejecutará puesto que esta restringido a los usuarios de nivel 5 . Otra forma de restringir el acceso a eventos es mediante el sufijo ‘!’ al nivel, que hará que el evento no se ejecute si fue accionado por usted mismo, por ejemplo: on 1!:OP:#:{ /echo $nick le dio op a $opnick } Este evento hará que cuando un usuario le de op a otro nos sea notificado en la ventana activa, a excepción de cuando sea usted el usuario que da op Y al igual que restringimos el accceso a ciertos eventos también podemos tener eventos de “libre acceso” por todos los usuarios, independientemente del nivel que tengan usando un ‘*’ en lugar del nivel: on *:JOIN:#:{ echo $chan Ha entrado $nick } Ese evento mostrará un mensaje en pantalla cada vez que entre un usuario a un canal, sin tener en cuenta su nivel. También podemos usar el prefijo ‘@’ para indicarle al script que ese evento solo salte cuando tengamos OP en ese canal, por ejemplo: on @10:JOIN:#:{ op $nick } Este evento hará que cuando un usuario de nivel 10 entre a un canal en el que estemos, y en el que seamos op, le demos op automaticamente Resumiendo un poco esta última parte en la siguiente tabla de ejmplos: Evento Accesible por usuarios de nivel: on 100:PART 100 o superior on +30:DEOP Únicamente 30 on 5!:QUIT 5 o superior (excepto usted!) on *:JOIN Todos on @30:NICK 30 o superior (solo si usted es OP en el canal)



82

Visto esto, y para finalizar, se va a realizar un ejemplo que mezcle los Usuarios Remotos con lo que vimos al principio de este documento sobre eventos CTCP, el objetivo será crear un medidor de LAG, algo que es fundamental en cualquier script.

Ejemplo 1: Creación de un medidor de LAG Para medir el lag que se tiene con una cierta persona, lo que se hace, como ya sabe, es hacerle a esa persona un CTCP PING, pues bien si usted quiere hallar el lag con usted mismo, es decir su propio lag con el server, lo que tendrá que hacer es como ya habrá adivinado, hacerse un CTCP PING a usted mismo, por lo tanto analicemos un poco en que se basará nuestro medidor para que despues nos sea más fácil construirlo: Primero necesitaremos un TIMER , es decir que cada ‘X’ segundos el mIRC nos haga automaticamente un PING para hallar nuestro lag. Despues necesitaremos que la respuesta a ese ping se nos muestre en un formato diferente al habitual y que la respuesta habitual se omita, pero habrá que tener en cuenta que cuando hagamos un ping a nosotros mismos, la respuesta que recibiremos será del tipo “Tu lag es de X segundos”, para ello usaremos el evento “ctcp 1:ping”. El problema es que si en ese evento ponemos una linea que diga “Tu lag es de X segundos” ese ctcp saltará cada vez que alguien nos haga un ping, sea quien sea, y lo que haremos en este ejemplo es que ese evento solo se ejecute cuando la persona que le haga el ping sea usted misma, de esa forma conseguiremos que cada vez que usted se haga un ping (automaticamente mediante el timer) se active el evento ctcp del ping que usted habrá diseñado y que cuando sea otra persona la que le haga un ping, ésta reciba el mensaje estándar. Pasemos ya a ver el código para este ejemplo, y posteriormente l acabaremos de comentar: Copie lo siguiente en “Aliases”: /medidor { /timer 0 30 ctcp $me PING /auser 55 $me

}



83

Copie lo siguiente en “Remotes”: ctcp 55:PING:{ %lag = $ctime - $2 titlebar Lag: %lag halt

} on 1:CONNECT:{ medidor } Y ya está, lógicamente este es un medidor de lag bastante primitivo en el sentido de que se le pueden añadir muchas más cosas, pero esta es la base y a partir de ella usted podrá ir elaborándo su propio medidor de lag con sus conocimientos. La explicación es bastante simple, cuando usted conecte a un servidor de IRC (salta el evento on 1:connect) se ejcutará el alias “medidor” que iniciará un timer infinito (de ahí el ‘0’ como primer parámetro) que consistirá en hacerse a usted ($me) un CTCP PING cada 30 segundos. Además cuando conecte usted será añadido a la lista de usuarios remotos con nivel 55. Al cabo de 30 segundos se producirá por primera vez ese CTCP PING que pusimos en el timer, y puesto que el ping lo manda usted que es un usuario de nivel 55, saltará el evento “CTCP 55” que calculará el lag y lo mostrará en la barra de título del mIRC mediante el comando “titlebar”, por ultimo se usa un “halt” para que la respuesta predeterminada del mIRC al PING quede escondida. Y obviamente si cualquiero otro usuario le hiciera un ping, como usted será el único con nivel 55, este evento no saltará y por tanto el otro usuario recibirá la respuesta estándar del PING.



84

NUMEROS Y EVENTOS RAW

INTRODUCCIÓN Constituye esta parte del mIRC uno de los apartados con más fama de escabrosos y difíciles para los aficionados a los scripts; la verdad es que no es para tanto, el programa permite trabajar con este recurso de una manera bastante sencilla, y presentar resultados de configuración muy espectaculares y potentes. Vamos a analizar el tema paso a paso y veremos porqué no es tan fiero el león como lo pintan. Las características del trabajo con los números raw en el mIRC requiere unos mínimos conocimientos sobre los eventos, los comandos, y los demás apartados de la creación de scripts; no me refiero a un dominio absoluto, pues en caso de necesidad puede hacer una consulta rápida en los capítulos correspondientes, pero sí, cuando menos, una cierta familiaridad con el significado de los conceptos que en ellos se manejan. Superada esta etapa verá que no se trata más que un poco de lo mismo, pero con nuevas capacidades que le sorprenderán. Vamos en primer lugar a centrar los conceptos. Cuando leyó la información relativa a los comandos del mIRC descubrió una serie de ordenes que puede dar a su programa. Estas órdenes o acciones digamos que pueden ser de tres tipos: - En primer lugar hay algunos comandos que le afectan solo a usted y a su sesión de trabajo con el mIRC: presentar mensajes con /echo, cambios de colores y fuentes, creación de ventanas personalizadas, ...etc. Estas acciones no tienen influencia ninguna en los demás usuarios ni en los servidores de IRC.

- Existen por otra parte comandos que implican acciones sobre, o referidas, a los demás usuarios sin pasar nunca por los servidores, hasta el punto de que, si en el transcurso de algunas de ellas pierde su conexión con el server, no perderá en cambio el contacto con el otro usuario, ejemplos de este tipo de acciones son: envío y recepción de ficheros y chats privados, acciones remotas, ping, version, finger, sound,...; son en general las acciones CTCP (client to client protocol) que suelen dar lugar a los eventos CTCP que explicaré en su correspondiente apartado, no son estas tampoco las que nos ocuparán primordialmente en este capítulo.



85

- En tercer lugar están las acciones referidas directamente a su conexión con un servidor de IRC, en su mayoría son órdenes o requerimientos de usted hacia el server, y a las cuales este responde de una determinada manera, y, a menudo, con un mensaje concreto indicando el resultado de la acción. Pensemos por ejemplo en los comandos /who, /whois, /names, /lusers, /list, /links, ...etc. En virtud de cualquiera de estos usted recibe una respuesta del server, bien sea un mensaje de error, o bien la información correspondiente. Existen dos maneras de enviar estos comandos, bien por el método habitual, es decir, empleando el comando del mIRC correspondiente, o bien mediante el comando: /raw <orden>. Básicamente la mayor diferencia de este último con el anterior es que usted no deja el trabajo a su programa, sino que envía la orden directamente de una forma similar a un "notice" hacia el server. Muchas de las órdenes válidas para el comando /raw (comandos del server) son idénticas a los comandos clásicos de su cliente que tienen el mismo fin, pero otras tienen variaciones, por tanto es necesario conocer la sintaxis exacta de la orden raw que enviamos para que esta funcione como deseamos. El mIRC utiliza el comando /raw en forma similar que otros clientes usan el comando /quote, aunque este también es válido en mIRC. Por ejemplo, para obtener una lista de los comandos disponibles en el server puede teclear: /quote help.

Como ejemplo curioso no me resistiré a comentar una de las bromas favoritas de los supuestos "expertos" hacia algún pobre "Giles" que encuentran desprevenido y preguntando alguna cosa como por ejemplo:

<^Gil[de]la Kuna^> Hola, ¿como puedo conseguir OP? O:-) ***Set mode: comentario mío (veremos que ocurre ) <SuperVivo> Es fácil, escribe: /raw server Opme

Y a los pocos segundos nuestro pobre amigo ^Gil[de]la Kuna^ se encuentra mirando confuso su ventana de estatus leyendo algo así como que se ha desconectado del server y el programa no puede reconectar. ¿Qué ha sucedido?. Muy sencillo, ^Gil[de]la Kuna^ a lo mejor incluso sabía que el comando: /server <servidor_de_IRC> [puerto] Sirve para desconectar del server actual y establecer inmediata conexión con otro server indicado, pero ignoraba que: /raw server <servidor_de_IRC> [puerto]



86

Hace exactamente lo mismo, con la única salvedad, en este caso, de que no existe ningún server de IRC que se llame Opme, y por lo tanto los intentos de su programa serán infructuosos. Que feo ...no?. En castigo ahora yo debería relacionarle una larga lista de comandos raw, pero no se preocupe, no lo haré, más que nada porque esto tiene en este momento muy poco interés para nosotros, ya que muchos son repeticiones de lo que hacen los comandos de cualquier buen cliente de IRC actual y otros exigen el estatus de IRCop. Pero lo que sí nos interesa aquí son las respuestas del server a nuestros comandos, a nuestra orden el server responderá casi siempre con una o más líneas de mensaje, estas líneas tienen siempre la misma estructura y, aunque no lo veamos, se identifican cada una con un número. Estos son los números raw. Si usted solo tenía curiosidad en el tema confío en que esta explicación se la haya aclarado; si su interés es saber como aprovechar esta circunstancia para la creación de sus propios scripts, continúa.

PRIMER CONTACTO CON LOS NÚMEROS RAW Vamos a empezar analizando un ejemplo clásico. Como sabemos el comando /whois <nick> hace que el server nos facilite cierta información acerca del nick de usuario que hemos introducido. Por ejemplo, imaginemos que tecleamos: /whois ^Gil[de]la Kuna^, y obtenemos esta respuesta:

^Gil[de]la Kuna^ es [email protected] * Gilote ^Gil[de]la Kuna^ #Donde-Viven-los-Giles @#Gil-Mayor ^Gil[de]la Kuna^ se encuentra en conectados.ciudad.com.ar IRC Server End of /WHOIS list.

Este es el formato básico habitual de la respuesta de un server ante un Whois de un nick que se encuentra en línea. Si el resultado que usted obtiene es distinto se debe probablemente a que usa un script que modifica este mensaje mediante el uso de los números raw, por tanto aquí debemos de partir de esta respuesta en formato estándar, tal y como llega desde el servidor. Lo que en realidad hemos recibido han sido cuatro mensajes (cuatro líneas), estas tienen siempre la misma estructura, aunque varíe su información, y cada una tiene asignada un número identificativo, es su número raw.



87

• La primera comienza siempre por el nick del usuario del que hemos pedido la información, después la palabra "es" y a continuación su User ID (el que especificó en la ventana IDENTD del setup), separado por una @ de la identificación de su conexión a Internet (ctcreuna.cl por ejemplo). Termina la línea con un asterisco y su Full Name, el que escribió en el Setup. Esta línea tiene siempre el número raw 311 y se conoce como: RPL_WHOISUSER.

• La segunda línea es la respuesta raw número 319 (RPL_WHOISCHANNELS). Esta comienza por el nick y detalla todos los canales en los que este se encuentra; incluso muestra el símbolo @ delante de aquellos nombres de canal en los que este usuario tiene estatus de OP.

• La tercera línea comienza también con el nick, e identifica el servidor de IRC que está usando. Es la respuesta raw número 312 (RPL_WHOISSERVER).

• La última línea no es más el mensaje estándar de final del envío de información para ese comando, y es siempre igual. Tiene el número rawn 318 (RPL_ENDOFWHOIS).

Otra posibilidad es que el nick del cual hemos solicitado la información no se encuentre en la red de IRC, en este caso la respuesta sería: ^Gil[de]la Kuna^ No such nick/channel End of /WHOIS list.

La primera línea es un mensaje indicándonos la ausencia del usuario, es el número raw 401 (ERR_NOSUCHNICK), la segunda es el raw 318 ya visto antes, que indica el final del mensaje. Lógicamente, llegados a este punto nos podemos hacer dos preguntas: ¿Cómo puedo usar esto para que la respuesta al comando /whois tenga el formato que yo quiera? y ¿Cómo puedo saber los números raw de cada respuesta del server a un comando?. La primera la resolveremos de inmediato, la segunda un poco más adelante.



88

LOS EVENTOS RAW

Una vez que nuestro programa recibe la respuesta del server a un comando o requerimiento por nuestra parte, si conocemos el número raw (paciencia, los conocerá ), es posible configurar el mIRC para que inhiba la respuesta normal, y nos presente el formato que nosotros queramos diseñarle. Cuando recibimos un mensaje catalogado con un número raw se produce un suceso o evento que nosotros podemos interceptar; es decir, podemos crear una instrucción que le diga a nuestro programa algo así: "Cuando recibas una respuesta raw con este número haz lo siguiente..." asociándole el código correspondiente mediante una rutina de script, igual que se hace con los eventos convencionales (ver el capítulo de Eventos del mIRC). La sintaxis para esto es una línea que especifica el número raw del evento que se espera, y la acción o acciones que han de realizarse en es momento: raw <número>:*:<acción> Vemos que la línea consta de tres campos, el primero es simplemente el número raw ante el que se desea actuar; el último es una o más acciones (comandos o alias) que se desea que se ejecuten en ese momento; el segundo es normalmente un asterisco que indica que se realice la acción sea cual sea el texto del mensaje que recibamos, es decir, que se haga siempre lo mismo ante este raw concreto, independientemente del nick, o cualquier otra información que nos devuelva es server. Si describimos más de una acción asociadas al evento debemos de separar cada una de las órdenes con el símbolo entubador: "|", teniendo buen cuidado de que este símbolo tenga espacios en blanco a ambos lados. Por ejemplo: raw 312:*: echo -s $1 está conectado por: $3- | halt El raw 312 es la respuesta RPL_WHOISSERVER, es decir, la línea del /whois que informa sobre el server de IRC por el que está conectado el nick. Con la sentencia anterior estamos diciendo a nuestro mIRC que cuando reciba esta respuesta debe de imprimir en status (de ahí el echo -s) una frase que comience por la primera palabra de la que hemos recibido del server, sea cual sea (representada por $1), que en el raw 312 es siempre el nick como hemos visto), a continuación la



89

cadena: "está conectado por:", y a seguidamente la tercera palabra recibida más todo lo que viene a continuación (por eso el signo - detrás de $3). Recordemos que una palabra se considera a cualquier cadena de caracteres que no contiene espacios en blanco en su interior, así "andesmedia.irc.com" se toma como una sola palabra ($3 en el ejemplo, puesto que es la tercera palabra). Hay una segunda orden en este evento: halt; este comando interrumpe cualquier acción posterior relacionada con el mismo, esté especificada por nosotros o no, el efecto en este ejemplo es el de inhibir la impresión de la respuesta del server, así se consigue que en caso de hacer un /whois nos aparezca solo la frase configurada por nosotros, y no la del server (si no ponemos halt se imprimirían las dos). Es así como podemos sustituir limpiamente las respuestas normales de los comandos que enviamos al servidor por otras con la sintaxis que deseamos, incluso con la posibilidad de añadir colores ... etc; es más, podemos también iniciar acciones automáticamente con solo incluir alias previamente creados, u otros comandos. Lógicamente las líneas de configuración de los eventos raw no podemos insertarlas en cualquier lugar a nuestro gusto, es necesario que estén allá donde el mIRC las puede encontrar, este lugar es la sección de remote de nuestro programa. Recordemos que en esta ventana se nos presenta el contenido de todos nuestros ficheros de script para events, ctcp's y remotes. Es buena costumbre tener los eventos raw agrupados en un fichero especifico para ellos, para conseguirlo un sistema puede ser seguir estos pasos:

• Desde el Explorador del Windows (por ejemplo), vaya al directorio donde tiene los archivos .INI del mIRC, que normalmente será el propio directorio del programa o un subdirectorio de este. En este lugar cree un nuevo fichero de texto y nombrelo "raw.ini", de momento déjelo en blanco.

• Entre en mIRC y luego Herramientas/Remote. En el diálogo que aparece abra el menú Archivo selecciones la opción Cargar, y a continuación la sub-opción Script (herramientas/remote/archivo/cargar/script). Verá otro diálogo de navegación en el que deberá de localizar y seleccionar el archivo creado: "raw.ini", ahora pulse el botón Ok. Todo esto se logra de igual manera tecleando la orden: /load -rs raw.ini.

• Ya está, el nuevo archivo se ha cargado en la memoria RAM correspondiente a mIRC como fichero de script, ahora podrá observarlo en



90

la ventana de Remote, si ha seguido los pasos anteriores evidentemente estará vacío, pero a la espera de que usted inserte ahí el código que desee. Si quiere volver a visualizar cualquier otro de sus ficheros de script no tiene más que abrir el menú Ver de esta ventana y seleccionarlo.

Sobra decir que estos mismos pasos los puede realizar para crear archivos (específicos para su comodidad) para eventos convencionales, CTCP's, ... etc. Puede tener tantos como desee. Así mismo también puede crear grupos de código raw igual que de cualquier otro tipo de código de script, es decir, encerrándolos entre líneas de activación, de tal modo que solo operarán cuando usted lo desee:

#nombre_grupo [on/off] Líneas de código...

#nombre_grupo end De este modo puede tenerlo activo (on) o inactivo (off) a su gusto con el uso de las órdenes: .enable #nombre_grupo o .disable #nombre_grupo desde un alias o una opción de popups (para más información al respecto repase los primeros apartados del capítulo Los Eventos del mIRC, que se refiere a los eventos convencionales).

REFERENCIA DE LOS NÚMEROS RAW. Solo un dato nos falta para poder comenzar a crear código de script para configurar nuestro programa ante las respuestas raw y es, evidentemente, conocer los números asociados a cada una de ellas. Desgraciadamente para nuestra capacidad retentiva, y afortunadamente para lo que podemos llegar ha hacer con ellos, son una enorme cantidad, por lo que mi primera recomendación debe de ser que dedique algún tiempo a examinar los que se encuentran en los muchos scripts para mIRC de uso gratuito que puede obtener en la w.w.w., y en esta misma web. De este modo no solo descubrirá el número de cada uno de ellos, sino que tendrá también ocasión de analizar algunas buenas ideas de lo que se puede conseguir. "Destripar" scripts, como yo le llamo, es la mejor manera de aprender a hacerlo, estas páginas solo pretenden que usted pueda llegar a tener una comprensión mas o menos clara de lo que está viendo cuando entre en el código de alguno.



91

No obstante no se preocupe, pretendo facilitarle todas las herramientas que necesita para poder trabajar con provecho con esta faceta del mIRC, yo personalmente recurro a dos ficheros muy útiles como referencia de los números raw: Por un lado el archivo "numeric.hlp" es una completa referencia (en inglés y espero tenerlo traducido pronto) de los números raw, se trata del "Jeepster's numeric reference". Incluye una completa lista en formato .help para Windows y alguna información más de interés. Este archivo de ayuda tambien puede ser bajado de la página de este manual. La segunda no es mas que un archivo de script que fue creado por Somatic con la idea de que cada vez que introdujese un comando dirigido al server me informase de cual era el número raw de cada una de las líneas que recibía, el nombre de esta (solo a título informativo), y el mensaje estándar que la acompañaba. De este modo, al cargarlo si quiere saber, por ejemplo, cuales son los raw correspondientes a la respuesta de un /who no tiene más que introducirlo y ver la información que le facilita en su estatus. Tome nota del dato y trabaje con él. Este segundo archivo se llama "rawtool.ini" y también lo puedes bajar desde la página de este manual. Bájelo y cárguelo en su mIRC copiándolo en el directorio del programa tecleando /load -rs rawtool.ini. Puede descargarlo cuando desee tecleando: /unload -rs rawtool.ini. Puede hacer lo mismo desde la sección Remote, menú Archivo opción Cargar subopción Script; y para descargarlo simplemente opción Descargar cuando lo tenga en la pantalla de edición de esta ventana. Para concluir permítame reiterar la importancia de la observación y la práctica para llegar a crear buenos scripts, espero que los conceptos que ha aprendido aquí le sirvan como base para esta labor. En cualquier caso no dude en dirigir sus comentarios, críticas o consultas a [email protected].



92

CONTROLDE SOCKETS EN mIRC

Introducción a los Sockets En muchos aspectos la opciones de los sockets en mIRC se quedan muy cortas, pero son muy utiles. Los sockets (o zócalos de conexión) son los puertos lógicos a través de los cuales los programas de nuestro ordenador se comunican con el resto de máquinas de una red a la que está conectada (por ejemplo de Internet), su manejo desde mIRC nos permite tener un cierto control sobre estas conexiones, abrirlas, cerrarlas, "escuchar" posibles accesos por cualqiera de ellas... etc. No podemos decir que sea una característica ni muy bien implementada ni muy potente en mIRC, pero si que nos permitirá hacer scripts muy interesantes con la posibilidad de crear escaneadores de puertos, detectores de accesos a nuestra máquina... etc; a medida que se expliquen en este documento podremos ir viendo algunos ejemplos de todo esto. Para explicar el uso de los sockets partiremos de la base de que ya se conoce perfectamente el manejo de otras areas programables del mIRC, en especial los alias, popups y el uso de variables, identificadores, eventos y remotes en general. Si no es así será necesario que estudie previamente los capitulos correspondientes a esos temas en este mismo manual. Es necesario indicar, por último, que los sockets es un recurso que se agota, cada vez que hayas terminado de usar un socket debes cerrarlo para poder usar otro, es decir, no se puede estar trabajando con más de un zócalo de conexión a la vez.

Identificadores de los sockets Los siquientes identificadores son los básicos que se han de saber para poder trabajar con los sockets. Hay más que se pueden ver en la ayuda del programa, pero no son tan importantes ni tienen una explicación tan extensa. $sock(nombre,numero) [.propiedad] Retorna información referente a una conexión con sockets que hemos creado usando los comandos correspondientes. Si en "numero" no se especifica nada y se deja con el valor "N", mIRC asumira que es 1.



93

Este identificador tiene las siguientes propiedades: .name el nombre de la conexión que utilizamos, para identificarla. .sent el numero de bytes enviados despues que la conexión se haya terminado. .rcvd el numero de bytes recibidos despues que la conexión se haya terminado.

.sq/.rq el numero de bytes de la cola para mandar y recibir buffers respectivamente.

.ls/.lr el numero de segundos desde el ultimo envio y recibo de información de la conexión.

.mark el área máxima de almacenamiento del usuario, 512 bytes.

.type el tipo de conexion socket, TCP o UDP

.saddr la direccion y el puerto de origen del ultimo paquete UDP.

.sport exactamente lo mismo que la propiedad anterior (.saddr). $sockname Es el nombre que le hemoss dado a una conexion para identificarla. Este identificador puede ser usado en los eventos para saber con que conexion se trabaja. $sockerr Sirve para comprobar si se ha realizado la conexión correctamente sin fallos. Si resulta haber algun fallo en ella este identificador devolverá un valor mayor que 1. Si todo esta normal no devolvera ningun valor. $portfree(Puerto) Sirve para comprobar si un puerto esta siendo utilizado o no. Devolverá $true si el puerto esta libre o $false si está siendo usado ya.

Detectando conexiones con los sockets Explicaremos como poner a la escucha un puerto determinado para detectar conexiones entrantes, pero primero vamos a ver los comandos y los eventos que vamos a utilizar: /socklisten <nombre> [puerto] Nos permite asignar un nombre a un pueto determinado a fin de identificar la conexión y poderlo usar más adelante.



94

on 1:socklisten:nombre:comandos Este evento se activa cuando cualquier usuario intenta conectar por el puerto que estamos "escuchando". Si queremos aceptar esta conexión usaremos el comando /sockaccept, si no la conexión será cerrada. /sockaccept <nombre> Este comando acepta la conexión actual que hemos detectado con el evento anterior, y le asigna un nombre para identificarla. /sockrename <nombre> <nuevo_nombre> Permite renombrar una conexion existente. /sockclose <nombre> Cierra la conexion especificada, si no se indica ninguna se cierran todas. Vamos a poner un ejemplo y a analizarlo para entender mejor todo esto. crearemos una pequeña rutina para detectar si un usuario intenta conectar por el puerto 12345 (Netßus). Incluir en aliases o popups: /socklisten Netbus 12345 « ponemos a eschuchar el puerto 12345, con el nombre Netbus Incluir en Events, en remotes: on 1:socklisten:NETBUS:{ « se activará cuando intentan conectar con la conexion Netbus /sockaccept Netbus69 « acepta la conexion y le pone el nombre de Netbus69 beep « mIRC producira un pequeño pitido de aviso echo -a detectado una conexion por parte de $sock($sockname,1).ip « nos informa de la IP del usuario /sockclose Netbus69 « cerrará la conexión con el usuario que ha intentado conectar } A partir de aquí se puede crear un script para resolver el nick del usuario haciendo un who con la IP.



95

Abriendo y Cerrando Conexiones Los sockets nos permiten abrir conexiones, por ejemplo para detectar los puertos abiertos de otro usuario. Vamos a ver los comandos y eventos que hemos de saber antes de hacer nada: /sockopen <nombre> <direccion> <puerto> Inicia una conexion con el puerto y la direccion IP que especificada. on 1:sockopen:nombre:comandos Este evento se activa cuando la conexión ha sido establecida mediante el comando /sockaccept. on 1:sockclose:nombre:comandos Este evento se activa cuando la conexion ha sido cerrada por el otro usuario. Vamos a poner un ejemplo y a analizarlo para entenderlo mejor. Este ejemplo sirve para detectar si un usuario tiene abierto el puerto 12345 (Netßus). Aliases o popups: /sockopen Netbus 195.77.120.10 12345 « abrimos una conexion por el puerto 12345 con 195.77.120.10 Events, en remote: on 1:sockopen:Netbus:{ « la conexion ha sido aceptada if ( $sockerr > 1 ) { « el usuario no tiene el puerto 12345 abierto

echo -a PortScan » $sock($sockname,1).ip no esta infectado por el Netßus }

else { « si el $sockerr no es >1 es que esta infectado por el Netßus echo -a Portscan » $sock($sockname,1).ip esta infectado por el Netßus }

/sockclose Netbus « cierra la conexion Netbus } Bueno, con este ejemplo ya teneis un scan de Netßus de lo más sencillo, ya que aun se puede mejorar mucho.



96

Leer y Escribir Información /sockwrite [-tn] <nombre> <texto> Envia información a una conexion ya establecida lo más repetido posible. Los parametros son:

-t aunque el texto comienze por &, este sea tomado como texto y no como una variable binaria

-n inserta una nueva linia de texto en la conexion on 1:sockread:nombre:comandos Este evento es llamado cuando el otro usuario recibe la informacion Observe este ejemplo, cuando un usuario intente entrar por el puerto 12345 le aparecera un mensaje: En popups o alias: /socklisten TONTIN 12345 En events, remotes: on 1:socklisten:TONTIN:{ « Cuando intente la conexion... /sockaccept TONTAZO « Acepta la conexión /sockwrite -n $sockname Uix, muy listo no eres $sock($sockname,1).ip « Le manda un mensaje /.timer69 1 2 /sockclose $sockname « En 2 segundos se le termina la conexion echo -a Detectada una conexion de $sock($sockname,1).ip por el puerto 12345

}



97

If-then-else

La estructura IF-ELSE permite establecer una bifurcación o alternativa dentro de una secuencia de ordenes. Es decir, en ocasiones es posible que deseemos que el programa ejecute una instrucción o instrucciones, pero solo si se cumple determinada circunstancia, y, en caso contrario, o bien no hacer nada, o bien ejecutar otras instrucciones diferentes. Por ejemplo, queremos hacer un alias que a intervalos de un minuto mida nuestro lag, y solo si este supera los 15 segundos nos envíe un mensaje a la pantalla de Status avisándonos de cuanto lag tenemos. Esto no es posible hacerlo mediante una secuencia lineal de instrucciones; es preciso que el programa discierna en algún momento si procede o no ejecutar la orden de imprimir un mensaje. Esta posibilidad es la que nos facilita la estructura IF. En definitiva, IF comparará valores, y ejecutará o no diferentes instrucciones, en función del resultado de la comparativa. Esta orden compara del contenido de dos variables, y solo en caso de que la primera variable sea mayor que la segunda enviará un mensaje a la pantalla de Status, y hará sonar un sonido Wav que supuestamente tenemos dentro de un directorio de la unidad C: llamado "sonidos". Obsérvese que la condición del if se debe de poner entre paréntesis, y las instrucciones internas a ejecutar estarán encerradas entre llaves (si solo hay una instrucción no son necesarias las llaves). Como se puede ver en la sintaxis general del if, junto este se pueden emplear otras dos instrucciones: elseif y else, aunque estas solo de forma opcional. Si podemos leer la sintaxis de IF de la siguiente forma: Si ( pasa esto ) { Haz esto } La del elseif equivaldrá a: En caso contrario, si ( pasa esto ) { Haz esto }. El anexo else es una posibilidad que permite ejecutar una serie de instrucciones en caso de que lo anterior no se haya producido. Las instrucciones comprendidas dentro del else se ejecutarán siempre que no hay resultado cierta la condición del if ni, de existir, la del elseif. Si no se especifica un else, el script sencillamente



98

continuará a desde la instrucción siguiente al último "}", o bien terminará si no hay nada más. Es perfectamente posible "anidar" instrucciones if, es decir, incluir más if’s dentro del bloque de instrucciones de un if. Por ejemplo, queremos hacer un alias que se llame "números". Este, al ejecutarse, nos pedirá tres números cualesquiera que cargará en tres variables, a continuación evaluará cual es el mayor de los tres y nos lo imprimirá en la ventana de Status. Podríamos hacer algo como lo siguiente: /números { set %A $$?="Introduce el primer número" set %B $$?="Introduce el segundo número" set %C $$?="Introduce el tercer número" if ( %A > %B ) { if ( %A > %C ) { echo -s El mayor es %A } else { echo -s El mayor es %C } } } elseif ( %B > %C ) { echo -s El mayor es %B } else { echo -s El mayor es %C } unset %A %B %C

Los operadores de comparación que podemos utilizar dentro de la condición de un if son los siguientes:

A == B A Igual a B A != B A distinto de B A < B A menor que B A > B A mayor que B A >= B A mayor o igual que B A <= B A menor o igual que B A // B A es múltiplo de B A\\B A no es múltiplo de B A isin B La cadena de caracteres A se encuentra incluida dentro de la

cadena B A iswm B La cadena A es idéntica a la cadena B A isnum B A es un número incluido dentro de la cadena de números B.

Si no se pone B se evalúa simplemente si A es un número A isletter B Igual al anterior pero con letras en lugar de números



99

A ison B El nick A está en el canal B A isop B El nick A es operador en el canal B A isvo B El nick A tiene voz en el canal B A ischan A está en este momento en el mismo canal que nosotros A isauto B El nick A está en muestra lista de auto-op para el canal B (B

opcional) A isignore A está en nuestra lista de ignorados A isprotect B

A está en nuestra lista de protegidos en el canal B (B opcional)

A isnotify A está en nuestra lista de notify En esta tabla se han usado, para hacerla más comprensible, los operándos genéricos A y B; en su lugar podemos usar valores numéricos, cadenas de caracteres, variables (identificándolas con su nombre precedido del símbolo %), o identificadores (con su nombre precedido del símbolo $). Si anteponemos el símbolo ! delante de cualquiera de los operadores de la tabla anterior este será negado, es decir, la condición se evaluará como cierta no cuando suceda eso, sino cuando no suceda. Por ejemplo : Este alias lista los Ops en salon donde nos encontramos. Este es el camino dificil, desde el momento que podemos usar el comando $opnick() en vez de utilizar el comando $nick() del servidor, pero esto nos dara un ejemplo de cómo el isop puede ser utilizado y de cómo el $null es devuelto una vez que alcanzamos el final de la lista. listops { echo 4 * Escuchando Ops activado en # set %i 1 :next set %nick $nick(%i,#) if %nick == $null goto done if %nick isop # echo 3 %nick es un Op! inc %i goto next :done echo 4 * Fin de la lista de Ops }



100

Este es un alias con definicion y activacion desde popups que le da Ops a los nick seleccionados en la lista de nicks. DarOps { %i = 0 %nicks = "" :nextnick inc %i if ($snick(%i,#) == $null) { if ($len(%nicks) > 0) mode # +oooo %nicks | halt } %nicks = %nicks $snick(%i,#) if (4 // %i) { mode # +oooo %nicks | %nicks = "" } goto nextnick } Este remote intercepta los Pings y envia un mensaje sobre los cerca o lejos que se encuentra el usuario. on 1:ctcpreply:PING* { if ($2 == $null) halt else { %pt = $ctime - $2 if (%pt < 0) set %pt 0 if (%pt < 5) echo 4 [PING reply] $nick esta demasiado cerca para mi gusto elseif (%pt < 20) echo 4 [PING reply] $nick se encuentra a la distancia correcta else echo 4 [PING reply] muerde el polvo $nick, muerde el polvo $nick } halt }



101

Hasta ahora hemos visto como la estructura if puede evaluar una condición simple; no obstante es también posible crear condiciones complejas combinando varias con o operadores lógicos. El mIRC admite dos tipos de operadores lógicos para enlazar entre sí dos o mas condiciones simples formando así una sola condición múltiple:

• Operador AND (&&). En castellano "y": Si (( pasa esto ) y ( esto ) y ( además esto )) { Haz esto } Por ejemplo: if (( $me !iswm PorotoMan ) && ( $me isop #Maduras_y_Maduros )) { mode $me -o # Maduras_y_Maduros } Esta instrucción comprobará si mi nick es distinto de PorotoMan, y además si tengo el estatus de operador dentro del canal #Maduras_y_Maduros, de suceder ambas cosas me retirará dicho estatus.

• Operador OR ( || ). En castellano "o": Si (( pasa esto ) o ( esto ) o ( esto otro )) { Haz esto } Por ejemplo: if (( %A > 20 ) || ( %B < 10 )) { echo -s Variable fuera de rango } Esta orden comprobará que la variable %A contiene un número en el rango [10-20] , en caso contrario manda al status un aviso.



102

EL COMANDO GOTO La orden goto provoca un salto automático dentro de la secuencia que el programa utiliza para leer las líneas de un script, pasando directamente a leer a partir de una determinada etiqueta, las líneas que continúan a partir de esta. Una etiqueta no es más que una palabra que ocupa una línea del script, y que se identifica como tal por tener el símbolo ":" delante. La llamada a una etiqueta desde la orden goto no debe de llevar los dos puntos delante. El uso del comando goto es un recurso muy útil en especial cuando se utiliza desde dentro de una estructura if. La sintaxis de este comando es: goto <etiqueta> Ejemplo: /CargaVar { :PideDato

set %valor $$?="Introduzca un número entre 0 y 9" if (( %valor < 0 ) || ( %valor > 9 )) {

echo -a Dato erróneo, introduzca solo un dígito entre 0 y 9 goto PideDato

} }

Este alias es una sencilla rutina que nos permite aceptar valores para una variable, depurando que solo se introduzca un dígito entre 0 y 9, de no ser así el alias volverá una y otra vez a la etiqueta PideDato solicitando un nuevo valor para la variable. EJEMPLOS: 1- El siguiente alias nos presentará la lista de operadores del canal en que nos encontramos en este momento. Se puede observar el empleo de la instrucción de salto incondicional (goto), el uso del parámetro $nick(canal,numero), el comando inc(%variable), y la estructura if.



103

/listaOPs { echo -a * Listando Operadores en # set %i 1 :sigue set %nick $nick(#,%i) if ( %nick == $null ) { goto final } if ( %nick isop # ) { echo 3 %nick is un Op! } inc %i ;(Se incrementa en uno la variable %i) goto sigue :final echo -a * Fin de la lista de operadores de #.

} 2- Este ejemplo presenta un alias que imprimirá en la pantalla de Status una tabla de los caracteres ASCII entre el 33 y el 241 ambos inclusive. /TablASCII {

set %num 33 echo -s Tabla ASCII :presenta if ( %num > 241 ) { goto fin } echo -s $chr( %num ) es el carácter ASCII carácter ASCII número: %num inc %num goto presenta :fin echo -s Fin de la tabla.

}



104

VVVEEENNNTTTAAANNNAAASSS PPPEEERRRSSSOOONNNAAALLLIIIZZZAAADDDAAASSS SSSTTTAAANNNDDDAAARRR

Las Ventanas Personalizadas en el mIRC El mIRC nos permite la creación de ventanas personalizadas que no son más que "ventanas" con diferentes atributos (que aprenderemos a asignar y modificar) y que pueden ser usadas para cualquier tipo de acción, generalmente para mostrar informacion al usuario, ya que se hace de una manera más limpia y ordenada que mostrando toda la información en la ventana de Status. Después veremos que tambien pueden ser usadas para la creación de GUI's (Interfaces Graficas de Usuario) mediante las picture Windows o ventanas de imagen. Este documento está pensado para que el lector y aprendiz de scriptter tenga un primer contacto con las ventanas personalizadas y sea capaz de crearlas y manipularlas a su gusto. Se han suprimido algunas funciones del comando window bien por el escaso uso de estas o porque suponen alguna dificultad añadida que solo la experiencia con el scripting nos ayudaria a superar. En el presente texto se utilizarán las sigientes convenciones para presentar la sintaxis de instrucciones y comandos: los argumentos entre < y > representarán valores que es necesario introducir para la correcta ejecucion del comando, mientras que los argumentos entre [ y ] son opcionales, y pueden ser omitidos a la hora de ejecutar el comando. La manera de seguir el documento, y aprender con él, es leerlo de arriba a abajo, siguiendo todos los ejemplos y probandolos todos antes de seguir. Tambien es conveniente que el lector modifique a su gusto los ejemplos que aquí encontrará para que vaya experimentando con los comandos de creacion/modificacion de ventanas personalizadas. En este tutorial aparecen mucho las palabras "editbox" y "listbox", se refieren, respectivamente, al campo de texto que tienen en la parte inferior ciertas ventanas (como las ventanas de los salones), y a las listas de 'objetos' seleccionables que tienen tambien ciertas ventanas (como la lista de nicks en los salones).



105

Y, por último, antes de empezar, en este tutorial se presupone que el lector ya es medianamente experto en el uso de Aliases, Popups, y Eventos Remotos

Creación de Ventanas Para crear una ventana personalizada usaremos el comando window con la siguente sintaxis: /window [-acdeEhkl[N]noprswx] [+bdelLmnstx] <@nombre> [x y [w h]] [popup] Por ejemplo: /window –ad @miventana 10 10 200 100 Introduzca esta orden en mIRC y descubrirá que ha creado una nueva ventana de windows, verá que su nombre es "miventana" (el símbolo @ debe de especificarse siempre al principio del nombre, esto corresponde al argunento <@nombre> en la sintaxis general). Hemos utilizado dos parámetros en esta orden: -a y -d, esto ha supuesto que se ha mostrado como ventana activa de windows y su icono ha aparecido en la barra de tareas de la parte inferior de la pantalla. Observe que al utilizar dos parámetros segidos solo hemos necesitado un símbolo "-" delante de ellos. Los números 10 10 200 100 especifican la ubicación y dimensiones de la ventana (corresponden respectivamente a los parámetros x, y, w, h); los dos prineros deterninan la posición dentro de la pantalla, los dos últimos sus dimensiones (ancho y alto). La posición de la ventana se basa en un sistema de coordenadas que toma como origen la esquina superior izquierda de nuestra pantalla, y sitúa la esquina superior izquierda de la ventana en el punto indicado, en este caso coordenadas 10,10. Volvamos a la sintaxis general del comando window para analizarla más despacio, resulta un poco imponente pero veremos como examinando cada una de sus partes es bastante más asequible de lo que parece. Existen dos grupos de parámetros que podemos emplear, por un lado [-acdeEhkl[N]noprswx] y por otro [+bdelLmnstx]. De inmediato veremos la utilidad de cada elemento de estos grupos. Una vez escritos los parámetros deseados especificaremos el nombre que queremos dar la la ventana (siempre con



106

@ delante). A continuación no queda sino concretar ubicación y tamaño de la ventana, no es necesario especificar ninguno de los dos, en ambos casos se asumen unos valores por defecto. También tenemos la posibilidad de incluir al final del comando el nombre de un fichero de popup's si deseamos que la ventana cuente con sus propios menús emergentes, es decir, aquellos que aparecen pulsando sobre ella con el botón derecho del ratón. A continuacion puede ver una descripcion de para que sirve la primera tanda de parametros del comando window que definiran el estado de la ventana: -a : Activa la ventana. -c : Cierra la ventana.

-d : Abre la ventana como ventana de escritorio ( se puede acceder a ella desde la barra de ventanas de Windows). -e : Añade a la ventana un editbox o línea de escritura (como la que tienen en la parte inferior los canales).

-E : Añade a la ventana un editbox de múltiples lineas líneas. -h : Esconde la ventana. -k : Esconde el prefijo '@' del nombre de la ventana. -w : Devuelve el prefijo '@' al nombre de la ventana. -l[N] : Añade una listbox (lista de elementos) a la ventana. Si se especifica N (opcional) se crea una listbox con N caracteres de largo.

-n : Minimiza la ventana. -o : Si la ventana es una ventana de escritorio, este parametro la pone y mantiene siempre encima de todas las ventanas (on top).

-u : Desactiva el poner la ventana encima de todas (on top). -p : Crea una ventana de imagen o "picture window" (esta opción será analizada en un capitulo aparte).

-r : Restaura una ventana despues de minimizarla. -s : Organiza por orden alfabético la ventana. -S : Organiza por orden alfabético la listbox de una ventana. -x : Maximiza la ventana.

Hasta aqui hemos visto la primera tanda de argumentos del comando window , no se asuste, la inmensa mayoria de las veces solo usará uno o dos de estos argumentos, pero esta bien que los conozca por si los necesitara para alguna ocasión en especial.



107

Ahora vamos con la segunda tanda de argumentos del comando, estos definirán la apariencia de la ventana: +b : Dibuja un pequeño borde alrededor de la ventana. +d : Ventana sin borde. +e : Dibuja un borde un poco mas ancho y redondeado. +l : Ventana de utilidades. +n : Boton de minimizar. +s : Se puede cambiar de tamaño. +t : Con barra de titulo. +x : Con boton de maximizar.

Después tenemos que indicar el nombre de la ventana a crear/modificar : <@nombre> : Por ejemplo, @mi_ventana Por último indicamos (opcionalmente) las coordinadas de la posición inicial de la ventana ( x y ) así como su longiud y altura (en pixels). w (longitud) h (altura) [ x y [ w h ] ] : por ejemplo, 100 100 300 100 Las coordinadas x y significan la distancia en pixels desde el extremo izquierdo de la pantalla, y desde el extremo superior de la ventana principal del mIRC (¡ojo, que no es lo mismo que el extremo superior del monitor!). Por ultimo el parámetro [popup] sirve para especificar un archivo que contenga el menú popup de la ventana (que aparecera al hacer click con boton derecho sobre la misma). Se puede especificar un archivo (cuya extension NO sea .ini) o bien el mismo nombre de la ventana (Ej: @mi_ventana) si se quiere implementar el popup dentro de los remotes del script.

Edición/Modificación de Ventanas Ahora que el lector ya sabe las posibilidades del comando window, veremos, ya creada la ventana, que comandos podemos usar para modificar la informacion que se muestre en ella.



108

El parámetro [c] esta presente en todos estos comandos, e indica el color principal de la linea que añadirá, borrará, o modificará . En cualquier caso también se peden especificar controles de color (ctrl + k + color), negrita (ctrl + b) y subrayado (ctrl + u) en el parámetro <texto>. Estos comandos se refieren siempre a actuar sobre la ventana principal, en caso de que queramos actuar sobre una listbox a un lado de la ventana, incluiremos el parametro -l entre el nombre del comando y el parametro [c], por ejemplo /aline -l @mi_ventana lo ke sea /aline [c] <@nombre> <texto> Añade la línea <texto> a la ventana <@nombre> Ejemplo: /aline 4 @mi_ventana Hola mundo!! /cline [c] <@nombre> <N> Cambia el color de la línea número <N> al color número [c] Ejemplo: /cline 4 #Maduras_y_Maduros 3 /dline [c] <@nombre> <N> Borra la línea (o el rango de lineas) numero <N> Ejemplo: /dline @nombre 1-10 /iline [c] <@nombre> <N> <texto> Inserta una línea (<texto>) en la posicion <N> Ejemplo: /iline @mi_ventana 2 Insertando una linea... /rline [c] <@nombre> <N> <texto> Sustituye la línea <N> por <texto> Ejemplo: /rline @mi_ventana 1 Hasta luego!! /sline [c] <@nombre> <N> Selecciona la línea numero <N> Ejemplo: /sline @mi_ventana 3



109

/renwin <@nombre> <@nuevo_nombre> [topic] Cambia de nombre la ventana <@nombre> y (opcionalmente) cambia su topic o descripción Ejemplo: /renwin @mi_ventana @tu_ventana Nuevo_topic Ahora que el lector ya conoce todos los comandos que se usan para la creación/modificación de ventanas, y antes de entrar en los eventos remotos asociados a las mismas, vamos a hacer un par de ejemplos de crear ventanas, para que se vaya familiarizando con estos comandos y compruebe por usted mismo que no es tan complicado como quizás parece en un principio: Ejemplo 1: Crear una ventana para dialogar con el usuario Vamos a crear una ventana que mostrará una informacion al usuario y esperara que éste le responda escribiendo en la editbox de la ventana: Para ello escribimos en la sección "Aliases" del Editor del mIRC: /vent { window -ae @dialogo 50 50 200 100 @dialogo aline 12 @dialogo Hola, ¿Cómo te llamas? } Si prueba ese ejemplo (escribiendo el alias "/vent" ), verá que se crea una ventana de nombre @dialogo con un editbox abajo y nos aparece en ella el texto "Hola, ¿Cómo te llamas?". En este momento nos tendremos que detener aqui, más adelante veremos como puede hacer que al teclear algo en la editbox y pulsar 'Enter' , el script le responda adecuadamente. Ejemplo 2: Ver un listado de archivos y mostrar informacion de los mismos En este ejemplo crearemos una ventana con una listbox, en la que apareceran los archivos mp3 de nuestro directorio de mp3 (se supondrá que es c:\mp3), y al hacer doble click sobre uno de los archivos se nos mostrara informacion de ese archivo en la ventana principal. Escribiremos el siguiente código en la seccion de "Aliases" en el Editor del mIRC:



110

/mp3 { window -l20 @mp3 50 50 600 200 @mp3 %i = 0 : comienzo inc %i 1 if (%i > $findfile(c:\mp3,*.mp3,0)) { goto fin } else { aline -l @mp3 $nopath($findfile(c:\mp3,*.mp3,%i)) goto comienzo } : fin unset %i

} En el alias /mp3 hemos hecho lo siguiente: Primero creamos la ventana @mp3 con una listbox (de tamaño 20 caracteres) y en la posicion x (50), y (50) y con un tamaño de 400 pixels de largo por 200 de alto. Despues creamos una variable temporal %i y le damos el valor '0'. Iniciamos un bucle cuya explicacion no forma parte de esta sección así que se explicará solamente en lineas generales lo que hace: incrementa %i en 1 y comprueba si el valor de %i es mayor que la cantidad de mp3s en el directorio c:\mp3, en caso de que %i sea mayor (querrá decir que ya no hay mas mp3) vamos al indicador ": fin" que dejara libre la variable temporal %i , y en caso de que el valor de %i sea menos que la cantidad de archivos mp3 en c:\mp3 (quiere decir que aun hay al menos un mp3 más), se añade una línea a la listbox de la ventana con el nombre del archivo (sin la ruta, de ahi el $nopath() ) El resto de funcionabilidad de la ventana, el mostrar informacion del archivo al hacer doble click sobre una de las lineas, la veremos más adelante cuando hayamos visto los eventos remotos.



111

Identificadores de Ventanas Personalizadas Estos identificadores pueden ser usados en cualquier Alias, Popup o Evento Remoto para recoger informacion sobre una determinada ventana: $line(@nombre,N,[T]) Devuelve el contenido de la linea N de una ventana. Si N es '0' devuelve el numero total de lineas en la ventana. El parámetro [T] es opcional, y se usa solo cuando nos referimos a una listbox en un lado de la ventana, para ello le daremos el valor '0' a T . Si nos referimos a una ventana sin listbox el parámetro [T] se omite, y si nos referimos a una ventana con listbox, pero queremos información de la ventana principal y no de la listbox, pondremos en lugar de [T] un 1. Ejemplo: //echo -s $line(@mp3,2,0) Devolverá el contenido de la segunda linea en la listbox de la ventana @mp3 $sline(@nombre,N) Devuelve el contenido de la linea seleccionada numero N (solo funciona en una listbox). Si le damos el valor '0' a N, devuelve el numero total de lineas seleccionadas en la listbox. $sline(@nombre,N).ln Devuelve el numero de la línea seleccionada numero N (N normalmente se pone '1') $window(@nombre).<propiedad> Devuelve las propiedades de una ventana. Los valores posibles de <propiedad> son: $window(@nombre).x : Devuelve la coordinada x de la posicion de la ventana. $window(@nombre).y : Devuelve la coordinada y de la posicion de la ventana. $window(@nombre).w : Devuelve la longitud en pixels de la ventana. $window(@nombre).h : Devuelve la altura en pixels de la ventana. $window(@nombre).dx : Devuelve la coordinada x de la ventana con respecto al escritorio (no a la ventana del mIRC). $window(@nombre).dy : Devuelve la coordinada y de la ventana con respecto al escritorio (no a la ventana del mIRC).



112

$window(@nombre).state : Devuelve el estado de la ventana (minimized, maximized, normal o hidden). $window(@nombre).title : Devuelve el texto en la barra de titulo de la ventana. $window(@nombre).font : Devuelve el nombre del tipo de letra actual en la ventana. $window(@nombre).fontsize : Devuelve el tamaño del tipo de letra actual en la ventana. $window(@nombre).fontbold : Devuelve $true si el tipo de letra esta en negrita, o $false si no lo esta.

Definición de popup's de Ventanas en la sección de Remotes Para definir el popup de una ventana personalizada sin necesidad de crearlos en un fichero aparte podemos editarlos dentro de la sección Remotes del editor del mIRC, la forma de hacerlo es la habitual de los popup's. Tan solo es necesario encerrarlos entre corchetes encabezar todo con la clausula MENU <@nombre_ventana>. MENU @nombre { Popup1 .Sub-popup: /accion1 .Sub-popup2: /accion2 - Popup2: /accion3 .....

} Eso sí, previamente tendremos que haber especificado en la definición de la ventana que queremos definir en popup en los remotes escribiendo el nombre de la ventana como el parámetro [popup]: Ejemplo: /window –a @nombre 10 10 100 100 @nombre También podemos definir el popup de varias ventanas a la vez poniendo: MENU @nombre1,@nombre2,@nombre3 { ... popup ...

}



113

Donde he puesto "...popup..." se ha de poner una secuencia de lineas con el formato normal de un Popup. Para que se entienda mejor el uso de esta técnica aquí va un ejemplo que debe ser copiado en la sección “Remotes” del editor del mIRC: alias miventana { window -a @mi_ventana 10 10 200 200 @mi_ventana

} Esto anterior tambien se puede hacer dentro te la sección de ALIAS poniendo: /miventana /window -a @mi_ventana 10 10 200 200 @mi_ventana. Y ahora ya sí, en remotes necesariamente: menu @mi_ventana { Decir Hola .En rojo : /aline 4 @mi_ventana Hola! .En negro: /aline 1 @mi_ventana Hola! Decir Adios .En Azul: /aline 12 @mi_ventana Adios! .En Verde: /aline 3 @mi_ventana Adios! - Cerrar Ventana: /window -c @mi_ventana

} El resultado de crear este codigo es que al teclear /miventana nos aparecerá una ventana personalizada en blanco y que, como le hemos especificado, usará como popup el menú @mi_ventana . Asi pues en el remote hemos declarado el "menu @mi_ventana" y le hemos escrito unos popups de la manera habitual. Si pulsamos el boton derecho sobre la ventana que hemos creado, veremos como aparece ese popup que hemos creado.



114

Eventos más Comunes en el uso de Ventanas Personalizadas on 1:INPUT:@nombre:{ comandos

} Este evento solo sirve para las ventanas que creemos que dispongan de una editbox, ya que el evento INPUT "salta" cuando introducimos texto en una editbox y pulsamos 'Enter'. También podemos usar el evento ON CLOSE: on 1:CLOSE:@nombre:{ comandos

} Los comandos que especifiquemos se ejecutaran cuando el usuario cierre la ventana, ya sea mediante un popup, o mediante el boton de cerrar (la 'X') de toda ventana de Windows. Y análogamente tambien disponemos del evento: on 1:OPEN:@nombre:{ comandos

} Estos comandos se ejecutarán cuando se abra la ventana indicada. Con lo que hemos visto hasta ahora, y un poco de práctica, el lector debe ser ya capaz de crear sofisticadas ventanas personalizadas, modificar sus atributos, añadirles menús emergentes, y ejecutar comandos cuando suceda algun evento en las mismas (como abrir o cerrar la ventana). A continuacion vamos a repetir, y esta vez a terminar, los dos ejemplos que se expusieron anteriormente, ya que ya se está en condiciones de poder darles toda su funcionabilidad con lo que sabemos hasta ahora:



115

Ejemplo 1: Crear una ventana para dialogar con el usuario Primero copiamos el codigo que ya habiamos hecho antes en los Aliases: /ventana { window -ae @dialogo 50 50 200 100 @dialogo aline 12 @dialogo Hola, ¿Cómo te llamas?

} Ahora nos vamos a la seccion "Remotes" y copiamos el siguiente codigo: menu @dialogo { Salir: window -c @dialogo

} on 1:INPUT:@dialogo:{ %vari01 = me llamo %vari02 = como estás? if ( %vari01 isin $1- ) { /aline 12 @dialogo Hola $3 !! } elseif ( %vari02 isin $1- ) { /aline 4 @dialogo Estoy bien gracias, y tu? } elseif ( estoy isin $1- ) { /aline 3 @dialogo Pues me alegro... } elseif ( idiota isin $1- ) { /aline 10 @dialogo Idiota tu !!!! } elseif ( adios isin $1- ) { /aline 5 @dialogo Nos vemos! | window -c @dialogo } else { /aline 6 @dialogo Lo ke tu digas... } halt

} Primero hemos creado la ventana @dialogo con el comando /ventana, a esta ventana le hemos indicado que ha de tener una editbox (-e) y por lo tanto nosotros podremos escribir en ella. Dependiendo de lo que escribamos, el script nos responderá de una forma u otra gracias al evento ON INPUT que controla el texto que escribamos en la ventana especificada. Creo que el código esta bastante claro asi que al lector solo le queda copiarlo en el editor del mIRC, probarlo y modificarlo a su gusto.



116

Ejemplo 2: Ver un listado de archivos y mostrar informacion de los mismos Primero copiamos el código que ya teniamos en los "Aliases" : /mp3 { window -l20 @mp3 50 50 600 200 @mp3 %i = 0 : comienzo inc %i 1 if (%i > $findfile(c:\mp3,*.mp3,0)) { goto fin } else {

aline -l @mp3 $nopath($findfile(c:\mp3,*.mp3,%i)) goto comienzo

} : fin unset %i

} Ahora vamos a los "Remotes" y copiamos: MENU @mp3 { dclick: {

aline 4 @mp3 $findfile(c:\mp3,*.mp3,$sline(@mp3,1).ln) aline 4 @mp3 $lof($findfile(c:\mp3,*.mp3,$sline(@mp3,1).ln)) bytes aline 4 @mp3 $duration($calc($lof($findfile(c:\mp3,*.mp3,$sline(@mp3,1).ln)) / 16000))

} Recargar mp3: window -c @mp3 | /mp3 - Salir: window -c @mp3

} Supongo que la principal pregunta al leer este codigo es: ¿Que es "dclick"?. Eso se explicará más adelante, cuando veamos las ventanas de imagen (picture windows), de momento ha de saber que el contenido de "dclick" se ejecuta cuando hacemos doble click sobre una ventana de imagen o (como en este caso) sobre una



117

listbox. Es decir que cuando hagamos doble click sobre alguno de los objetos de la listbox (que seran nombres de los mp3 que tengamos en el directorio c:\mp3) nos aparecerá en la ventana principal la ruta completa del archivo en la primera línea, el tamaño de ese archivo (usando el identificador $lof ) en la segunda línea y la duración aproximada del mp3, que se consigue dividiendo el tamaño del mismo por 16.000, en la tercera. Despues hemos añadido dos opciones al menú popup de la ventana, la primera “Recargar Mp3” consiste en cerrar la ventana, y volverla a abrir (usando el comando que habiamos creado anteriormente de nombre /mp3 ) Bien, vistos estos dos ejemplos, usted ya sabe lo suficiente como para hacer ventanas personalizadas muy complejas y útiles, aunque si este es su primer contacto con las ventanas personalizadas quizas sea una buena idea que antes de ponerse a hacerlas, vea mas ejemplos de como se hacen en algún script.



118

VENTANAS PERSONALIZADAS DE IMAGEN

Introducción Como se ya se describió en el capítulo "ventanas personalizadas" el parámetro –p del comando window hace que creemos una ventana de imagen. ¿Qué es una ventana de imagen? Pues básicamente es lo mismo que una ventana personalizada normal, con la diferencia de que en ésta en vez de añadir/borrar/modificar líneas de texto, lo que haremos sera dibujar puntos, lineas, figuras o incluso mostrar imágenes con formato .BMP. Así pues las picture windows no son más que tipo especial de ventanas personalizadas, y este capítulo lo dedicaremos integramente a estudiar su creación, manejo y posibilidades. Pasando ya a la práctica, un ejemplo de cómo crear una ventana de imagen podria ser el siguente: /window –p @mifoto 10 10 200 200 @mifoto Esta línea de código hará que se cree una ventana de imagen en blanco de nombre @mifoto (recuerde que las ventanas personalizadas siempre llevan en su nombre el prefijo ‘@’), en las cooridnadas x (10) y (10), de 200 pixels de largo por 200 de alto, y que además use los menús popup que le especifiquemos bajo la clausula o titulo ‘menu @mifoto’ en la seccion de “Remotes” del editor del mIRC. Hasta aquí no hacemos más que repetir lo que se explicó en el capítulo anterior, la diferencia es que esta es una ventana de imagen y nos permitirá aplicar tratamientos y procesos gráficos. Una vez creada la ventana ahora lo importante, y lo que la diferencia del resto, son los comandos u modificadores que podemos emplear en ella. Con los comandos que a continuación se explicaran el lector sera capaz de dibujar figuras, puntos, y lineas; poner texto en cualquier lugar, y mostrar imágenes .BMP tambien en cualquier posicion dentro de la ventana. Antes de empezar con este tema es importante definir a que me refiero cuando empleo la palabra "rectangulo". La especificación del rectángulo son 4 números que determinan la posición y tamaño de la ventana. Los dos primeros aluden a la posición en que se encontrará su esquina superior izquierda. El primero (x) será la distancia en pixels desde el borde izquierdo de la pantalla, el segundo (y) es la distancia desde el borde superior. Los dos sigueinte números definen el tamaño de



119

nuestra ventana: ancho (w) y alto (h), siempre usando el pixel como unidad de medida, por lo cual las dimensiones reales dependerán del tamaño y definición de su monitor. Por ejemplo un rectángulo cuya esquina esté en las coordenadas x = 30, y = 5, y mida 100 pixels de largo por 120 de alto lo expresaremos como: 30 5 100 120.

Comandos para la Modificación de Ventanas de Imagen. Estos comandos, igual que pasaba con los de las ventanas personalizadas “normales” se han de usar despues de haber creado la ventana, y pueden ser insertados en cualquier Alias, Popup o Remote que declaremos. /drawdot [–hnri] @nombre <color> <tamaño> <x y> [x y ...] Dibuja un punto del color indicado (del 0-15) con un diametro (tamaño en pixels) y en las coordinadas x y dentro ventana de imagen. No confundir estas coordenadas x e y con las coordenadas equivalentes que usamos al crear la ventana, en este caso aluden a la posición en que se dibujará el punto dentro de la misma. Corresponden a una escala en pixels que también parte de la esquina superior izquierda de la ventana creada, pero cuyos ejes son ahora el borde superior e izquierdo de la misma ( no de la pantalla ). Es decir, que si dibujamos un punto en las coordinadas x(0) y(0) tendremos un punto cuyo centro estara en la misma esquina superior izquierda de la ventana de imagen. Se pueden especificar multiples coordenadas ‘x,y’ en la misma orden, esto es, si queremos dibujar varios puntos con el mismo comando. Los parametros opcionales [-hnri] sirven para lo siguiente:

-h Hará que el icono de la ventana parpadee en el momento de dibujarse el punto si se encuentra minimizada.

-n Hace que la ventana no se actualice inmediatamente. Esto

podria ser util si antes de dibujar el punto queremos cambiar el color del fondo o algo similar, aunque realmente eso se conseguiria mas facilmente poniendo el comando



120

que cambiara el color de fondo antes que el que dibujara el punto asi que este parametro rara vez lo usaremos...

-r Indica que el <color> esta especificado en formato RGB

(Rojo,Verde,Azul). en caso de que usemos este parametro tendremos que utilizar el identificador: $rgb(rojo,verde,azul) por ejemplo: $rgb(0,200,100)

-i Dibujara el punto en modo inverso (color blanco y fondo

negro). Ejemplo: /drawdot –r @mifoto $rgb(255,23,45) 5 10 10 12 10 Este ejemplo dibujara 2 puntos en la ventana @mifoto del color definido por el valor $rgb(255,23,45) , con un diametro de 5 pixels. /drawline [-hnri] @nombre <color> <tamaño> <x y> <x y> [x y...] Dibuja una línea del color <color>, que tenga un grosor de <tamaño> pixels y que vaya desde las primeras coordinadas <x y> que especifiquemos hasta las segundas <x y>. Se pueden especificar opcionalmente más parametros <x y> para hacer una línea que pase por los puntos definidos. Los parámetros [-hnri] hacen exactamente lo mismo que en el comando drawdot, y de hecho comprobaremos que a casi todos los comandos de modificacion de ventanas de imagen se les pueden aplicar estos parámetros Ejemplo: /drawline @mifoto 4 10 20 0 20 100 Este ejemplo dibujará una linea en @mifoto de color rojo (4) y grosor 10 pixels, que irá desde las coordenadas x(20) y(0) hasta x(20) y(100) . Es decir será una linea vertical.



121

/drawrect [-hnrifec] @nombre <color> <grosor> <x y w h> [x y w h..] Dibuja un rectángulo del color <color> cuyo borde tenga un grosor de <grosor> pixels, cuya esquina superior izquierda se encuentre en las coordinadas <x y> especificadas, y que mida <w> pixels de largo por <h> de alto. Lógicamente si incluimos un segundo juego de parámetros [x y w h] creará un segundo rectangulo con esas características. Los parámetros [-hrni] una vez más son los mismos que los explicados en el comando drawdot, los otros sirven para lo siguiente:

-f Una vez dibujado el rectángulo lo rellena con el color que hayamos especificado para el borde, si no especificamos este parámetro el rectangulo por dentro será del color del fondo.

-e Dibuja una elipse en lugar en un rectángulo... ¿que como

dibuja una elipse si lo que le estamos dando son las coordenadas de un rectangulo? Pues simplemente dibuja la elipse que cabría perfectamente dentro de ese rectángulo que especificamos con <x y w h>.

-c Hace que el borde del rectangulo sea del color que le hemos

especificado, pero transparente. Ejemplo: /drawrect –fr @mifoto $rgb(1,2,3) 10 30 30 200 200 Este ejemplo dibujará un rectángulo de color $rgb(1,2,3) , ya que le hemos especificado el parámetro –r , que estará además relleno con ese color, y su esquina superior izquierda estará en la posición x(30) y(30) y medirá 200 pixels de largo por 200 de alto. /drawfill [–hnris] @nombre <color1> <color2> <x y> [archivo.bmp] Rellenará el área en el que esté el punto <x y> con el color <color1>. Podemos especificar que en vez de rellenar el área con un color se haga con una imagen BMP que tengamos. La imagen ha de ser del tamaño 8x8 pixels, si tiene cualquier otro tamaño no funcionará. Los parámetros [-hnri] cumplen la misma función que en los comandos anteriores.



122

La funcion del parámetro <color2> depende de si especificamos o no el parámetro [-s]. Si ponemos -s el valor de <color2> indicará el color que deberá ser sustituido por <color1>. Si no incluimos -s el valor que le demos a <color2> será el color ante el cual el relleno deberá parar. Este comando resulta un poco complicado de explicar, asi que lo mejor será que se fije en el siguiente ejemplo: Ejemplo: /drawfill @mifoto 1 4 30 30 c:\imagen.bmp Este ejemplo lo que hará es que usando la imagen imagen.bmp (cuyo tamaño es de 8x8 pixels) y desde la posicion x(30) y(30) pegara multiples copias de esa imagen para rellenar esa zona, parando ante cualquier línea de color rojo, si hubiera alguna. /drawtext [-hnrpboc] @nombre <color1> [color2] [Tipo_letra] [Tamaño_letra] <x y [w h]> <texto> Inserta un texto del color <color> en la ventana que especifiquemos y en las coordinadas <x y>. Podemos añadir opcionalmente la longitud y altura del texto (parametros [w h]), esto hará que si el texto que escribimos es demasiado largo y no cabe en el rectángulo que hemos indicado con [w h] aparezca solo el trozo que quepa. El parámetro [color2] es opcional y sirve para especificar el color del fondo del texto que escribamos. Los parámetros [Tipo letra] y [Tamaño letra] también son opcionales e indican el nombre del tipo de letra a usar (escribirlo todo junto, sin espacios) y su tamaño en puntos. [-hnr] tienen la misma funcion que en anteriores comandos. En cuanto a los otros parámetros:

-p Nos permite el uso de controles de color (ctrl + k) , negrita (ctrl + b) y subrayado (ctrl + u) dentro del texto.

-b ndica que se va a especificar el parámetro [color2] como

color de fondo para el texto. Si no usamos este parámetro, [color2] deberá ser omitido.

-o Indica que el tipo de letra elegido debe ser en negrita. -c Indica que los parámetros opcionales [w h] van a ser

especificados.



123

Ejemplo: /drawtext –b @mifoto 4 9 MSTimesNewRoman 14 30 40 Probando el comando drawtext Este ejemplo pondrá en pantalla la cadena de caracteres “Probando el comando drawtext” de color rojo (4) y sobre un fondo verde claro (9), con el tipo de letra Ms Sans Serif (recuerde que en el comando se ha de escrbir el nombre del tipo de letra todo junto, sin espacios), de un tamaño 14 puntos. /drawcopy [-ihnt] @nombre [color] <x y w h> @destino <x y [w h]> Copia parte de una ventana de imagen a otra parte de la ventana o a otra ventana. Si especificamos los parámetros [w h] la seccion de la imagen que hayamos copiado será ensanchada/estrechada a ese tamaño (el especificado por [w h]) en la ventana de destino. Fíjeses que si lo que quiere es copiar un trozo de una imagen desde una seccion de una ventana a otra sección de la misma ventana, @nombre y @destino serán la misma ventana. Los parámatros [-ihn] son los mismos que explicamos en /drawdot . y en cuanto a –t indica que hemos especificado el valor [color] como un valor $rgb equivalente al color que queremos que sea transparente en la imagen que hayamos copiado. Ejemplo: /drawcopy @miventana 0 0 100 100 @miventana2 10 10 Este ejemplo copiara el contenido de la ventana @miventana contenido desde x(0) y(0) hasta x(100) y(100) a @miventana2 en la posicion x(10) y(10) /drawsave @nombre <archivo.bmp> Guarda la imagen de fondo actual de la ventana @nombre como un archivo de nombre <archivo.bmp> Ejemplo: /drawsave @mifoto ventanita.bmp Este ejemplo guaradará la imagen de fondo que tengamos en la ventana @mifoto en un fichero con el nombre ventanita.bmp.



124

/drawscroll [-hn] @nombre <x> <y> <x y w h> Desplaza la región de la ventana comprendida en el rectángulo <x y w h> (recuerde: x – posición x de la esquina superior izquierda, y – posición y de la esquina superior izquierza, w – longitud del rectángulo, h – altitud del rectangulo, todo en pixels) <x> pixels en el eje X y <y> pixels en el eje Y. Los valores de <x> e <y> pueden ser un número negativo si queremos indicar que la región se desplaze hacia la izquierda o hacia abajo respectivamente. [-hn] son los mismos que en el comando drawdot Ejemplo: /drawscroll @mifoto 10 20 50 50 200 200 Este ejemplo desplazará la región de la ventana @mifoto contenida en el rectángulo “50 50 200 200” 10 pixels hacia la derecha y 20 hacia arriba. /drawpic [–ihntsc] @nombre [color] <x y [w h]> [x y w h] <archivo.bmp> Y llegamos sin duda al comando más útil de todos los de las ventanas de imagen, con este comando podremos cargar una imagen cualquiera <archivo.bmp> (con formato .bmp) en una ventana, en las coordenadas que indiquemos <x y> . Si indicamos la longitud y altitud [w h] la imagen sera ensanchada/estrechada a ese tamaño. El parámetro opcional [x y w h] lo usaremos para indicar qué parte del archivo <archivo.bmp> queremos mostrar, útil por si tenemos un bmp grande con varias imágenes y queremos mostrar solo una de ellas. [-ihn] corresponden a los parámetros explicados en drawdot. Otros parámetros que acepta este cmando son:

-t Indica que hemos especificado el valor [color] con el fomato $rgb(N,N,N) donde N es un numero comprendido entre 0 y 255, y ese color será tratado como transparente en el archivo que queramos mostrar.

-s Indica que hemos especificado los parámetros [w h] para

ensachar/estrechar la imagen. -c Indica que la imagen debe ser puesta en la memoria caché,

esto hace que si en la misma sesión quisieramos volver a hacer uso de esa imagen, el tiempo de carga sería muy inferior. La caché puede almacenar hasta un máximo de 30 imágenes, a partir de ese número empezaran a reemplazarse las que lleven más tiempo sin usarse por las más nuevas.



125

Ejemplo: /drawpic –t @mifoto $rgb(0,0,0) 0 0 c:\foto.bmp Este ejemplo mostrará la imagen c:\foto.bmp en la ventana @mifoto en las coordinadas x(0) y(0) y las regiones de la imagen de color $rgb(0,0,0) (negro en este caso) se mostrarán como transparentes (se verá el fondo de la ventana a través de esas regiones). Con esto acabamos con los comandos para la modificación de ventanas de imagen. Como habrá podido comprobar el dominio de las coordenadas x e y es imprescindible, y también la unidad de medida de tamaño de cualquier gráfico por ordenador, el pixel, para especificar los tamaños de las figuras y/o imágenes. Esto sólo se consigue mediante práctica, y los que anteriormente hayan usado un programa de diseño gráfico como Corel Draw o Photoshop ya tendrán algo de camino andado en este tema. Seguidamente veremos los identificadores que nos devolverán información específica de una ventana de imagen.

Identificadores de Ventanas de Imagen $mouse.<propiedad> $mouse.win : Devuelve el nombre de la ventana sobre la que se encuentra el raton. $mouse.x : Devuelve la posicion x , relativa a la ventana de imagen, del raton. $mouse.y : Devuelve la posicion y , relativa a la ventana de imagen, del raton. $mouse.mx : Devuelve la posicion x relativa a la ventana principal del mIRC. $mouse.my : Devuelve la posicion y relativa a la ventana principal del mIRC. $mouse.dx : Devuelve la posicion x relativa al escritorio. $mouse.dy : Devuelve la posicion y relativa al escritorio. $rgb(nº,nº,nº) Este identificador ya lo hemos usado en la explicación de los comandos, y sirve para especificar un color, pero con más detalle. Es decir que en vez de usar el color con un número del 0 al 15, los indicaremos suministrando los valores de rojo, verde y azul del color(RGB). Si no controlas el RGB no te preocupes siempre puedes poner el color el el formato habitual (numero del 0 al 15).



126

$getdot(@nombre,x,y) Devuelve el valor RGB del color del punto definido por los parámetros ‘x’ e ‘y’ . $inrect(x,y,x2,y2,w,h) Devuelve $true si el punto definido por x,y esta dentro del rectángulo definido por x2,y2,w,h . En caso contrario devuelve el valor $false. $height(texto,tipo_letra,tamaño) Devuelve la altura en pixels del texto especificado y con un tipo de letra y tamaño. Recuerda que el tipo de letra lo haa de escribir todo junto, por ejemplo: TimesNewRoman. $pic(archivo.bmp) Este identificador se puede usar de 3 formas: $pic(archivo.bmp).size : Devuelve el tamaño del .BMP especificado. $pic(archivo.bmp).height : Devuelve el tamaño del .BMP especificado. $pic(archivo.bmp).width : Devuelve el tamaño del .BMP especificado. $width(texto,tipo_letra,tamaño,B,C) Devuelve la longitud en pixels del texto especificado y con un tipo de letra y tamaño. Si el parámetro ‘B’ es diferente de ‘0’ se tomará el tipo de letra en negrita. Si el parámetro ‘C’ es diferente de ‘0’ se ignorarán el espacio ocupado por los controles de color, negrita y subrayado.

Eventos y Remotes en las ventanas de imagen Con las ventanas de imagen podemos usar los mismo eventos y manejo de remotes que empleabamos en el resto de ventanas personalizadas, como por ejemplo el evento ON INPUT (si la ventana contaba con una editbox) o los eventos ON OPEN y ON CLOSE que se ejecutaban cuando abriamos o cerrábamos la ventana en cuestión. En lo que se refiere a ventanas de imagen, no existe ningún evento remoto para ellas en especial, seguiremos usando por tanto los ya vistos en el capítulo anterior, pero eso sí, a la hora de definir menús Popup dentro de la sección Remotes para una ventana de imagen, sí que podrá incluir nuevas funciones que ayudarán a sus ventanas a ser un poco más útiles y sofisticadas.



127

Por ejemplo, usted podrá hacer que al pulsar en cierta región de una imagen pase una cosa, y al pulsar en otra región pase otra cosa. Vayamos por partes, como he dicho antes la nueva funcionalidad de las ventanas de imagen se implementará donde en las ventanas personalizadas normales implementábamos el menu Popup. Por ejemplo si creamos la siguiente ventana: /window –p @otraventana 100 100 100 100 @otraventana Y queremos definir su menu popup, escribiremos en la sección Remotes: menu @otraventana { } Y aquí empiezan los cambios. Por supuesto, es perfectamente posible especificar el menú popup que queremos para esa ventana dentro de los corchetes pero eso deberá ser puesto “al final”. Y me explico: antes de escribir el menú popup podremos incluir una serie de "gatillos" que saltarán cuando ocurra cierto evento. A continueación se detallan cuales son estos “gatillos” que usted podrá especificar dentro de la clausula “menu @otraventana”: mouse: Saltará cuando el ratón se mueva por encima de la ventana. sclick: Saltará cuando el usuario haga click con el botón izquierdo sobre la ventana. dclick: Saltará cuando el usuario haga click con el botón derecho sobre la ventana. uclick: Saltará cuando el usuario suelte el botón izquierdo del ratón. lbclick: Saltará cuando se haga un click sobre un objeto de una listbox. leave: Saltará cuando el ratón salga de a ventana (se mueva fuera de la ventana). Cuando usemos este gatillo, podemos usar el identificador $leftwin que nos devolverá el nombre de la ventana de la que salió el ratón. drop: Saltará cuando el usuario haga click con botón izquierdo sobre la ventana, mantenga el botón pulsado, mueva el ratón y después lo suelte otro lugar. Antes de complicarlos más, le presentaré un ejemplo de cómo podría usar estos click ( o gatillos) para que le quede un poco mas claro: menu @otraventana { mouse: /echo –s El ratón se ha movido hasta $mouse.x $mouse.y sclick: /echo –s Ha hecho click en las coordenadas $mouse.x , $mouse.y dclick: /echo –s Ha hecho doble click sobre las coordenadas $mouse.x , $mouse.y uclick: /echo –s Ha soltado el boton en las coordenadas $mouse.x , $mouse.y leave:{



128

echo –s Ha salido de la ventana $leftwin window –c $leftwin

} Popup 1 .sub-popup1: /comando1 .sub-popup2: /comando2 Popup2: /comando3 - Popup3: /comando4

} Ahora fíjese bien en el código que acaba de leer. Hay unas cosas importantes que deberían de quedar claras con ese ejemplo:

• Como ha visto los clicks de una ventana de imagen se especifican dentro de la clausula “menu @otraventana” y siempre ANTES que el menu popup.

• El menu popup de la ventana se especifica, normalmente, de la misma forma que en las ventanas personalizadas normales (después de los "clicks").

• Se puede hacer uso de los identificadores $mouse.x y $mouse.y para hallar las coordenadas en las que se encuentra situado el ratón (siempre relativas a la ventana de imagen).

• Se pueden incluir varios comandos para un mismo click usando llaves { } como hemos hecho en el ejemplo del click “leave”.

Aunque le parezca increíble, con lo que se ha explicado hasta ahora ya se puede hacer cualquier cosa que haya visto en cualquier script que tenga que ver con ventanas de imagen. El uso de estas ventanas no es sencillo, y se hace verdaderamente muy pesado, así que sería conveniente que el lector se asegurará de si en realidad va a valer la pena el hacer una ventana de imagen para algo que quizás un simple menu popup podría solucionar. De cualquier forma a continuación se va a exponer y explicar un ejemplo que aunque tenga una escasa utilidad servirá para que pueda ver todos estos comandos e identificadores en acción. En este ejemplo se da por hecho que los conocimientos del lector sobre Aliases, Remotes y popups son suficientes.



129

Ejemplo 1: Crear una imagen interactiva Para ello necesitaremos, primeramente, una imagen, usaremos la siguiente: Esta en concreto tiene unas dimensiones de 100x73 pixels, este valor nos será util más adelante, se supondrá que la imagen se encuentra en c:\pregunta.bmp.

Ahora, como ya habrá adivinado, lo que haremos será transformar esa imagen en una ventana de imagen, y hacer que si el usuario pulsa el ratón sobre “SI”, se cierre el mIRC y, si por el contrario, pulsa sobre “NO”, se cierre la ventana de imagen y que no ocurra nada más. Por lo tanto lo primero será crear un ALIAS que abra la ventana de imagen y cargue en ella pregunta.bmp. Copiaremos lo siguente en la sección “Aliases” del editor del mIRC: /pregunta { set %longitud $pic(c:\pregunta.bmp).width set %altitud $pic(c:\pregunta.bmp).height /window –p +b @pregunta 200 200 %longitud %altitud @pregunta drawpic –c @pregunta 0 0 c:\pregunta.bmp

} Hasta aquí lo que hemos hecho es sencillo, declaramos el alias “/pregunta”. Y lo que hará ese alias es guardar la longitud en pixels del la imagen en la variable %longitud , después guardará la altitud en pixels de la imagen en la variable %altitud. Seguidamente se declara la ventana de imagen @pregunta, usando el parámetro +b para que no tenga barra de título ni botones de minimizar, maximizar y cerrar. Hemos usado las variables %altitud y %longitud para que la ventana sea exactamente del mismo tamaño que la imagen, de esa forma esta ocupará toda la ventana y quedará bien (sin ningun espacio en blanco). Despues mediante el comando drawpic hemos cargado la imagen en la ventana que hemos creado y hemos metido esa imagen en la cache (mediante el [-c] ) para que si la volvieramos a utilizar en la misma sesion se cargara más rapidamente.



130

Ahora iremos a los remotes para definir el “menu @pregunta” y el gatillo que hará que cuando hagamos un click sobre “SI”, se cierre el mIRC, y que cuando hagamos un click sobre “NO”, se cierre la ventana. Copie lo siguiente en los “Remotes”: menu @pregunta { sclick:{

if ( $mouse.x > 49 && $mouse.x < 73 && $mouse.y > 46 && $mouse.y < 78 ) exit elseif ( $mouse.x > 118 && $mouse.x < 163 && $mouse.y > 44 && $mouse.y < 68 ) {

window –c @pregunta } else { /echo –s Haz click sobre “SI” o sobre “NO” ! }

} Información de la imagen .¿Cuánto ocupa?: /echo –s La imagen ocupa $pic(c:\pregunta.bmp).size bytes - Cerrar ventana: /window –c @pregunta

} Esta es la sección más interesante del código, y aquí se ha mostrado como se hará siempre que queramos hacer que ocurran cosas diferentes según en qué la región pulsemos de una imagen. Para ello se ha recurrido al gatillo “sclick” que como se explicó antes salta cuando el usuario hace un simple click sobre la ventana. Lo que pasará en este caso es que el script comprobará donde ha hecho el click, y dependiendo de donde sea, ejecutará unos comandos u otros. Pero al mIRC no le podemos decir “si el usuario clickea sobre el SI haz esto y lo otro”, al mIRC le tendremos que decir “si el usuario hace click en el rectangulo x y w h , entonces ejecuta estos comandos”. Y eso hemos hecho, primero hemos abierto la imagen en un programa de diseño, el Paint de Windows basta, y moviendo el ratón sobre la imagen nos aparece en la esquina inferior derecha del programa las coordenadas por las que estamos moviendo el raton, así pues apuntamos las coordenadas que definen el rectangulo que contiene a la palabra ‘SI’. En este caso el rectangulo tendria su esquina superior izquierda en x(49) y(46) y su esquina inferior derecha en x(73) y(78) .



131

Entonces le hemos dicho al mIRC: “si cuando el usuario hace click el raton esta entre las coornidadas x(49) y x(73) y además esta entre las coordinadas y(46) e y(78)” eso necesriamente significa que el usuario ha hecho click sobre la palabra ‘SI’ y por lo tanto ejecutaremos el comando exit , que cierra el mIRC, no hace falta que le digamos antes que cierre la ventana de imagen puesto que al cerrarse el mIRC se cierran automaticamente todas las ventanas que haya creadas. Análogamente se ha seguido el mismo procedimiento para detectar si el usuario hace click sobre ‘NO’, y en tal caso hacemos que se cierre la ventana de imagen y que no pase nada más. Por último le hemos dicho que si el click no se produce ni sobre la palabra ‘SI’ ni sobre la palabra ‘NO’ que nos salga un mensaje en la ventana de status indicándonos donde tenemos que pulsar. Visto eso, el resto es sencillamente el menú que aparecerá al pulsar boton derecho sobre la ventana, que se especifica, como ya sabe, despues de el/los gatillos que hayamos empleado. Hasta aquí este tutorial de ventanas personalizadas. Soy consciente de que al principio parecen muy complicadas, pero en realidad no lo son tanto, lo que sí son es muy pesadas de crear , por eso se recomienda que se usen sólo cuando sea estrictamente necesario, ya que la mayor parte de las veces se podría llevar a cabo la misma tarea, y de una forma más cómoda mediante popups. De cualquier forma, se han comentado con detalles todas las posibilidades de las ventanas personalizadas y de imagen para que también el lector ya experto les pueda sacar el máximo provecho.



132

TUTORIAL DE DIALOGOS EN mIRC

Unas palabras antes de empezar Los Dialogos fueron introducidos por primera vez en la versión 5.5 del mIRC. Los Dialogos son la manera que papá Khaled nos da para acceder al GUI (graphical user interface, interface gráfico de usuario). Son para algunos más complejas de usar que las ventanas gráficas, y para otros, como yo, menos. Como ya comentamos los Dialogos vienen implementados desde el reciente mIRC 5.5, pero es recomendable aplicarlos a partir de la version 5.51, que corrige algunos de los bugs de la anterior. Los Dialogos pueden parecer dificiles de entender en un principio, pero en un par de intentos los estarás usando con la misma facilidad que cualquier otro elemento del scripting del mIRC.

Creando un Dialogo Los Dialogos se abren usando el comando /dialog. Su formato básico es: /dialog -modificadores nombre tabla. El nombre es simplemente el que usaras para referirte a el en los remotes. La tabla es la base del Dialogo, o sea la definición de su estructura. Cuando se crea una tabla, es preferible usar una tabla no modal, o sea una tabla que no interrumpirá la ejecución del script y operará independientemente del script cuando sea llamada. Para crear una tabla no modal, se usa el modificador -m La tabla se pone en los remotes, con el prefijo "dialog". Dentro tendras que poner los identificadores de los objetos y los comandos para crear el Dialogo, con este formato: dialog <nombredelatabla> { comandos

} Todos los elementos incluidos en la tabla requieren su propia etiqueta identifier (id para acortar). De esta manera se asigna un nombre a cada elemento, que podra ser usado posteriormente en un evento DIALOG o con el comando /did. Los id no



133

tiene por que ir en orden secuencial (1 2 3 4 5 etc...) pero haciendolo así podras conseguir organizar los elementos del Dialogo mejor. El Id más pequeño que se puede usar es el 1 y el mayor el 250. Cada Id que pongas en la tabla ha de ser único, asi que no podrias tener en la tabla dos elementos con el Id de 7, por ejemplo. Es como en la vida real, por ejemplo los padres dan nombres individuales a sus hijos, si imaginamos a una familia con 5 hijos que no tuvieran nombres, como sabriamos cual es cual?. Lo mismo si tenemos gemelos y les llamamos a ambos Rodrigo, como distinguirlos?. Por eso la obligatoriedad y unicidad de cada nombre. Cualquier $identifier o variable no se evalua dentro de una tabla. Una tabla simple requiere al menos 3 elementos: Elemento Nº 1: El titulo. Es lo que aparecera en la barra de titulo de nuestra ventana Dialogo. Elemento Nº 2: Las medidas. Determinaran la forma básica de la ventana, tienen el mismo formato que las que usa el comando /window: x y w h (coordenadas x e y de la esquina superior izquierda de la ventana, y luego w anchura en pixels y h altura en pixels). Si quieres poner el Dialogo en el centro de la pantalla, donde x e y pon -1 en cada uno. Elemento Nº 3: Un boton de OK/Cancel. Si no esta presente, el Dialogo no se abrirá. El formato es: button "texto",id, x y w h,estilo (El estilo puede ser "default", "ok", o "cancel"). La x es la distancia en que el boton sera colocado, medida hacia la derecha desde la esquina superior izquierda del Dialogo. La y es la distancia en que el boton sera colocado, medida hacia abajo desde la esquina superior izquierda del Dialogo. La w es la anchura del botón y la h la altura. Ahora aplicaremos estos elementos para crear nuestro primer Dialogo. En los Remotes ponemos: dialog primero { title "Este es nuestro primer Dialogo" size -1 -1 300 100 ; este tamaño crea una ventana en la mitad de la pantalla (-1 -1) que sera 300 de ancha y 100 de alta. button "OK",1, 1 75 120 25, OK



134

; siempre se requiere un boton de OK o Cancel. El nombre del boton es 1. Sera colocado a 1 y 75 pixels de distancia de la ;parte superior izquierda del Dialogo, tendra 120 de ancho y 25 de alto, que es mas o menos el tamaño de un boton ;normal.

} Despues de crear el Dialogo, se visualiza con el comando /dialog -m primero primero Aparecera algo como esto: 1) Es el botón de OK que hicimos. No tiene por qué decir OK, puedes cambiarlo al texto que quieras. Su Id es 1.

2) Este es el título. Puedes cambiarlo en cualquier momento usando /dialog -t nombre texto.

Poniendo elementos dentro del Dialogo Ahora veremos una lista de elementos que puedes usar en la tabla. Cada elemento viene con un ejemplo, para activarlo se debe usar /dialog -m primero primero

Escribiendo texto en el Dialogo: Para ello debemos usar el elemento en la tabla. Su formato es: text "texto",id,x y w h, estilo El estilo es la alineación del texto, y es opcional. Los estilos son: Right: Pone el texto alineado a la derecha. Center: Pone el texto en el centro del area de texto. El area del texto es el definido por la anchura (w) y la altura (h). Ejemplo: dialogo primero { title "Este es mi primer Dialogo" size -1 -1 300 100 button "OK",1, 1 75 120 25, OK text "Hola Gente!!!",2, 1 1 100 25

}



135

Creando una zona de edicion: El elemento a incluir si queremos poner una zona de edición de texto es edit cuyo formato es: edit "texto",id,x y w h, estilo Los estilos son: Right, center, multi, pass, read, return, hsbar, vsbar, autohs, autovs Multi permite crear una zona de edición multilinea, para añadir lineas solo hay que incrementar el valor de "h". Pass permite crear una zona de edición de passwords, donde cada caracter que tecleamos se visualiza como un asterisco "*". Read hace a la zona de edición ineditable, y el area se colorea en gris. Puede ser usado para ventanas de información. Hsbar añade una barra de scroll horizontal. Vsbar añade una barra de scroll vertical. Autohs añade una barra de scroll horizontal invisible que te permite seguir escribiendo mas allá de la longitud de la zona de edición. Autovs es lo mismo pero para una barra vertical. Ejemplo: dialogo primero { title "Este es mi primer Dialogo" size -1 -1 300 100 button "OK",1, 1 75 120 25, OK edit "Texto por Defecto",2, 10 30 150 20

}

Para añadir una casilla: Usaremos el elemento check . Su formato es: check "texto",id, x y w h,estilo Los estilos son: left, push, 3state Push: Crea un botón de pulsar, no una casilla. 3state: Crea una casilla de tres estados: 1) sin marcar 2) marcado 3) Marcado con fondo gris.



136

Ejemplo: dialogo primero { title "Este es mi rpimer Dialogo" size -1 -1 300 100 button "OK",1, 1 75 120 25, OK check "3State Checkbox",2, 5 30 170 25,3state

} Una ventaja de usar casillas de 3estados es que se pueden "bloquear" ciertos parametros a activados o desactivados. Para bloquear nuestra casilla a "activado", por ejemplo, pondríamos el comando /did -cu first 2.

Para añadir un Boton de radio: Elemento necesario: radio. Formato: radio "text",id,x y w h,estilo Un boton de radio es así: Estilos: left, push Ejemplo: dialogo primero { title "Este es mi primer Dialogo" size -1 -1 300 100 button "OK",1, 1 75 120 25, OK text "Selecciona el Genero:",2, 1 1 140 25 radio "Masculino",3,1 20 60 25 radio "Femenino",4,1 40 60 25

} También se pueden hacer grupos de botones de radio, cosa que explicaremos más tarde.



137

Creando una Caja (frame): Elemento necesario: box. Formato: box "texto de titulo",id, x y w h,estilo No se conocen estilos disponibles. Ejemplo: dialogo primero { title "Este es mi primer Dialogo" size -1 -1 300 100 button "OK",1, 1 75 120 25, OK box "Informaciòn sobre el Script",2, 20 5 110 60 text "Nombre: Script Dialogo",3, 25 20 60 25 text "Version: 1.0",4, 25 45 60 25

}

Añadiendo un Icono Elemento necesario: icon. Formato: icon id, x y w h, nombre del fichero, indice El indice es el numero de orden del icono dentro del fichero que deseas usar. normalmente los ficheros de iconos sólo tienen un icono en su interior, si es así usarías 1 o incluso podrías omitir el parámetro. Si usas Windows 95/98/NT, puedes usar librerías de iconos como por ejemplo : C:\WINDOWS\SYSTEM\PIFMGR.DLL (Sustituye c:\windows por la ruta del Directorio donde tengas el Windows). El "w" y "h" designa un area del Dialogo en donde la imagen se dibujará. Si la imagen es mayor que este area, el mIRC la reducira hasta que entre. Ejemplo: dialogo primero{ title "Este es mi primer Dialogo" size -1 -1 300 100 button "OK",1, 1 75 120 25, OK icon 2, 1 1 36 36, C:\WINDOWS\SYSTEM\PIFMGR.DLL,1 icon 3, 40 1 36 36, C:\WINDOWS\SYSTEM\PIFMGR.DLL,2 icon 4, 80 -1 36 36, C:\WINDOWS\SYSTEM\PIFMGR.DLL,5

}



138

La primera linea de "icon" se refiere al primer icono localizado en pifmgr.dll que sera dibujado en un area de 36X36. La segunda linea de "icon" es el segundo icono localizado en pifmgr.dll que sera dibujado en un area de 36X36. La tercera linea de "icon" se refiere al quinto icono localizado en pifmgr.dll que sera dibujado en un area de 36X36. Podemos cambiar la imagen usando el comando dialog. El formato para ello es: /did -g nombre id [n] nombredelfichero [n] es el numero de indice opcional. Si el fichero solo contiene un gráfico, entonces [n] puede omitirse. De manera que para cambiar el último icono al icono de un teclado, usaremos: /did -g tryhi 4 12 c:\windows\system\pifmgr.dll

Creando una Lista desplegable Elemento necesario: list. Formato: list id,x y w h, estilo Estilos: sort,extsel

Sort: Cualquier texto que se incluya en la lista será ordenado alfabéticamente. Para añadir texto a la lista, usaremos el comando did -a nombre id texto. Se puede usar tantas veces como se necesite. Si añades más lineas de las que caben en el espacio visible, aparecerá una barra de scroll. La manera más fácil de crear una lista cuando creamos un Dialogo es usar el evento on *:DIALOG:first:init:0: (Este evento se explicará más tarde). Ejemplo: Ponemos en el Remote: on *:DIALOGO:primero:init:0:{ ;este evento reacciona cuando el Dialogo es creado (init) ;entonces se usa did -a para poner texto en el elemento cuyo id es 2 (que es la lista en este ejemplo) did -a first 2 Pera did -a first 2 Banana did -a first 2 Naranja did -a first 2 Manzanas did -a first 2 Piñas

} dialogo primero {



139

title "Este es mi primer Dialogo" size -1 -1 300 100 button "OK",1, 1 75 120 25, OK list 2, 1 1 70 70, sort

} Nota que el texto en la lista ha sido ordenado alfabéticamente.

Creando un Combo box Elemento necesario: combo. Formato: combo id,x y w h, estilo Estilos: sort, edit, drop Drop: Crea una lista desplegable. Ejemplo: En el Remote ponemos: Dialogo primero{ title "Este es mi primer Dialogo" size -1 -1 300 100 button "OK",1, 1 75 120 25, OK combo 2,1 25 120 140,drop text "Cual es tu Fruta Favorita?",3, 1 1 180 25

} on *:DIALOG:first:init:0:{ did -a first 2 Pera did -a first 2 Banana did -a first 2 Naranja did -a first 2 Manzanas did -a first 2 Piñas

}

Añadiendo y Borrando texto dentro de un Dialogo ya creado Esta tarea requiere el uso del comando /did. Su formato básico es: /did -parametros nombre id [n] [texto | nombredefichero] Todo lo que esta entre [ ] es opcional. Como queremos añadir texto a un elemento, necesitamos usar el parametro -a. También necesitamos saber el id del elemento al



140

que queremos añadir texto. Por ejemplo, podemos renombrar el botón OK usando el comando did. Para ello tecleamos, después de abrir el Dialogo: /did -a first 1 Pulsa Aqui Usamos el 1 porque el ID de los botones de OK es 1. Pero no estás limitado a renombrar botones, puedes añadir texto a la mayoría de los elementos. Por ejemplo, en el último ejemplo (combo) si queremos cambiar "Cual es tu fruta favorita?" a "Tu fruta favorita es?" usariamos el comando did. Como le dimos al elemento "Cual es tu..." el id de 3, lo incluiriamos en el comando did. /did -a first 3 Tu Fruta Favorita es? Si tratas de cambiar el texto de un elemento, asegúrate de que cabe. El parametro w en la mayoría de los elementos nos dice su longitud máxima y por lo tanto la del texto que queremos poner dentro de él. Si ponemos el valor de h mayor, entonces si el texto es demasiado largo saltará y continuará en una nueva línea. Borrar todo el texto en un elemento es similar a cambiarlo. Su formato es: /did -r nombre id. Ejemplo (usando el combo anterior). Abrimos el Dialogo, y tecleamos /did -r first 2. Si ahora pinchamos en el combo no debería de haber elementos dentro de él. Pero que pasa si sólo quiero borrar un elemento de los que hay en la lista del combo? Entonces usamos el comando /did -d nombre id numerodelinea. En el ejemplo del combo, tecleariamos /did -d first 2 3. El elemento "Naranjas" habra desaparecido del combo.

Agrupando Botones de Radio Sin grupos, mIRC asume que cada botón de radio de un Dialogo tiene relación con el anterior. Esto significa que en todo el conjunto del Dialogo, solo podrías tener un botón de radio seleccionado al mismo tiempo. La solucion es agrupar los botones de radio. Al contrario que los grupos del Remote, no hace falta especificar un nombre de grupo, ni empezar el grupo con #grupo on y acabarlo con #grupo end. Para comenzar un grupo, se pone en el parametro "estilo" del primer boton de radio del grupo, la palabra group. Pero solo para el primer boton de radio del grupo, no se puede poner group en el estilo de ningun otro boton de radio que vaya a ir en ese grupo. Estos grupos solo afectan a los botones de radio, a ningun elemento mas. Para empezar otro grupo, con lo que terminariamos también el



141

anterior grupo, se debe poner un boton de radio con la palabra group en el estilo. Veamos un ejemplo: dialog first { title "This is our first dialog" size -1 -1 300 100 button "OK",1, 1 75 120 25, OK text "Genero:",2,1 1 60 25 ;comienzo del primer grupo radio "Hombre",3,50 1 50 20,group radio "Mujer",4,100 1 60 20 text "Estado Civil:",5,1 25 120 25 ;aqui acaba el primer grupo y empieza el segundo grupo radio "Soltero",6,70 20 50 25,group radio "Casado",7,125 20 60 25 radio "Otro",8,190 20 60 25 text "Edad:",9,1 45 30 25 ;aqui termina el segundo grupo y empieza el tercero radio "Menor de 10",10,30 40 65 25,group radio "10 a 20",11,100 40 65 25 radio "Sobre 20",12,165 40 65 25

} El primer grupo de esta tabla empieza con el id 3, y termina con el id 4. El segundo grupo empieza con el id 6, y también contiene el 7 y el 8. El tercer y último grupo empieza con el id 10, y también tiene el 11 y el 12.

Mas cambios de apariencia (Parte 1) No solo puedes añadir o borrar texto de un Dialogo, también puedes enseñar/ocultar, dar foco/quitar foco, activar/desactivar, marcar/desmarcar, y mucho más. La mayoría de estos cambios se hacen con el comando /did. Pero antes de empezar a explicarlos, debemos conocer algo más del evento "on dialog". Este evento reacciona cuando algo pasa que afecta a algún elemento del Dialogo. El formato es: on *:DIALOG:nombre:evento:id:



142

Cuando se activa, el evento on DIALOG te permite usar tres nuevos identificadores, $dname, $devent, y $did. $dname es el nombre del Dialogo en que se activo el evento. $devent es el nombre del evento. $did es el id del elemento afectado. Hay varios tipos de eventos: init,sclick,edit,dclick. init: reacciona justo antes de que el Dialogo sea visualizado, los controles pueden ser inicializados con este evento. Su Id es cero. edit: reacciona cuando el texto de una zona de edición o de una combo cambia. sclick: reacciona cuando se da un click en una lista o combo, o se marca/desmarca una casilla o botón de radio, o se da un click en un botón. dclick: reacciona cuando se da doble click en una lista o combo. Si quieres ver lo que ocurre en cada momento en un Dialogo, usa este código: on *:DIALOG:name:*:*: { echo $dname $devent $did } Ahora vamos a cambiar un poco su apariencia, con los ejemplo que van a continuación.

Marcando/Desmarcando Radio/Combo Si quieres marcar/llenar/seleccionar a una casilla/radio/combo, se necesita el comando /did -c . Su formato es /did -c nombre id [numero]. El [numero] solo se usa para marcar combos. Ejemplos: Para marcar la casilla "Entrar a salon On Connect" abrimos el Dialogo (/ss) y en la ventana de status tecleamos /did -c setup 18 Para poner un punto en "Masculino" en el grupo de botones de radio de Genero, abrimos el Dialogo y tecleamos en la ventana de estado: /did -c setup 11 Para seleccionar un canal en la lista de Favoritos, abrimos el Dialogo y tecleamos: /did -c setup 14 2 Eso seleccionaría el segundo canal favorito de la lista.



143

Si quieres desmarcar una casilla o boton de radio debes usar el comando /did -u command. Su formato es: /did -u nombre id Ejemplos: Para desmarcar la casilla " Entrar a salon On Connect ", teclea en la ventana de status: /did -u setup 18 Si estas usando una casilla de 3 estados, entonces usariamos -cu como modificadores, lo que dejaría gris la casilla. Para quitar el punto del boton de radio Masculino del grupo Genero, tecleariamos en la ventana de status: /did -u setup 11

Dando/Quitando Foco a un Elemento Dar foco a un elemento es añadir un pequeña linea de puntos a su alrededor, como en el texto "Join Channels On Connect" de la imagen anterior. El formato para dar foco a un elemento es: /did -f nombre id. El formato para quitar foco a un elemento es: /did -t nombre id. Ejemplos: Para poner foco en el botón "Agregar Salon", teclea /did -f setup 14 Para quitar foco a ese botón, tecleamos /did -t setup 14

Activando/Desactivando Elementos Cuando desactivas un elemento, se pone de color gris. Para desactivar un elemento: /did -b nombre id Para volverlo a activar, si estaba desactivado: /did -e nombre id Ejemplos: Para desactivar el botón "Quitar Salon", tecleamos en la ventana de estado: /did -b setup 16 Para activar el botón "Quitar Salon", tecleamos en la ventana de estado: /did -e setup 16



144

Ocultando y Mostrando Elementos A base de ocultar elementos, podemos llegar a lograr distintas configuraciones de Dialogo en una misma ventana de Dialogo. Podemos ocultar el botón OK para usar la ventana solo para mostrar cosas, o tener sólo una ventana de Dialogo llena de elementos, de los cuales solo mostrariamos unos u otros dependiendo de las circustancias. Para ocultar un elemento, tecleamos /did -h nombre id Para mostrar un elemento, tecleamos /did -v nombre id Ejemplo: Vamos a suponer que no queremos que en la ventana que estamos usando como ejemplo se vea el botón "Entrar a Salon", entonces tecleariamos en la ventana de status: /did -h setup 17 Y si lo queremos hacer visible de nuevo, tecleariamos: /did -v setup 17

Más Cambios de Apariencia (Parte 2) Ahora te preguntas: "Pero quiero hacer esos cambios en los dialogos automáticamente, como?". Aquí es donde entra el evento on DIALOG de nuevo. Como dijimos antes, el evento on DIALOG reacciona cuando pasan ciertas cosas en la ventana de Dialogo. Si quieres cambiar la apariencia de algunos elementos cuando el Dialogo se carga por primera vez, debes usar este formato del evento: on *:DIALOG:nombre:init:0: comandos. Asi también es como puedes insertar variables/identificadores en el Dialogo, que luego puedes evaluar con /did y /dialog. on *:DIALOG:setup:init:0: { ;setup es el nombre del Dialogo. init es el evento que se activa ;la primera vez que se carga el Dialogo. 0 es el Id por defecto cuando un init sucede. did -a setup 21 < 5 did -a setup 21 5 to 9 did -a setup 21 10 to 14 did -a setup 21 15 to 19 did -a setup 21 20 to 24



145

did -a setup 21 25 to 29 did -a setup 21 29 to 34 did -a setup 21 34 to 38 did -a setup 21 38 to 42 did -a setup 21 43+ ;estos did -a añaden elementos al combo desplegable que selecciona tu edad. ;asi se añade texto a un combo (ya sea un combo normal o desplegable). if (%setup.connect == $null) { set %setup.connect off } if (%setup.connect == on) { did -c setup 18 } ;este did -c comprueba el " Entrar a salon On Connect " si has pinchado sobre el previamente if (%setup.nick != $null) { did -a setup 5 %setup.nick } ;si ya has rellenado un nick entonces esto te lo mostrará if (%setup.alt != $null) { did -a setup 7 %setup.alt } ;si ya has rellenado un nick alternativo entonces esto te lo mostrará if (%setup.real != $null) { did -a setup 9 %setup.real } ;si ya has rellenado un "nombre real" entonces esto te lo mostrará if (%setup.gender == male) { did -c setup 11 } ;si has seleccionado "male" como género, entonces did -c setup 11 pondrá ;un punto en el botón de radio de "masculino" if (%setup.gender == female) { did -c setup 12 } ;si has seleccionado "female" como género, entonces did -c setup 12 ;pondrá un punto en el botón de radio de "femenino" update.setup ;update.setup es un alias que añade todos los canales favoritos al combo de canales favoritos.

} Cuando alguien hace un click (sclick) en un elemento del Dialogo, el evento sclick es activado. El identificador $did tendra el id del elemento sobre el que se hizo el click. Si el sclick fue en una casilla, una manera de saber el estado actual de esa casilla es usar $did(id).state. Si la casilla está marcada, devolverá 1, si está desmarcada devolverá 0. Si la casilla está en gris, desactivada, devolverá 2. Cuando alguien teclea o borra texto de una zona de edición el evento EDIT se activa. Si se usa dentro del evento on DIALOG, $did(id).text devolverá el texto que hay en la zona de edicion.



146

Otros Comandos de los Dialogos Aquí están algunos de los otros comandos/parámetros que aun no he explicado: Hacer el Dialogo una ventana de escritorio: /dialog -d nombre Cambiar el título del Dialogo: /dialog -t name TITULO Cambiar el tamaño del Diálogo: /dialog -s nombre x y w h Hace que el Dialogo esté por encima de las demás ventanas: /dialog -o nombre Quita la característica el Dialogo de que esté por encima de las demás ventanas: /dialog -n nombre Hacer click en el botón de OK (lo que cierra la ventana): /dialog -k nombre Hace click en el botón de Cancel (lo que cierra la ventana): /dialog -c nombre Inserta texto en un elemento: /did -i nombre id linea Sobreescribe texto en un elemento: /did -o nombre id linea texto



147

EL COMANDO /dialog (2) Creará una ventana de diálogo totalmente independiente de la tarea que el mIRC esté realizando en ese momento, es decir que mientras la ventana de diálogo permanece abierta usted podrá acceder a las otras ventanas del mIRC (cosa que no pasaba con los diálogos $?, $dir,... etc). Para mostrar en pantalla un diálogo, usaremos la sintaxis: /dialog [–mda] <nombre_dialogo> <nombre_tabla> Donde <nombre_dialogo> es aquel con el que usted se referirá al mismo, y <nombre_tabla> es el nombre de una tabla de diálogo que usted tendrá que declarar más adelante y en la que diseñará su aspecto, dimensiones y contenido (posición de los botones, botones de radio,... etc). NOTA: Se puede, y de hecho es recomendable, usar el mismo nombre para el nombre del diálogo y para la tabla, para evitar posteriores confusiones. A continuación tiene una explicación de la función de los tres parámetros disponibles, tenga en cuenta que el parámetro -m es obligatorio y sin él no se creará nuestra ventana de dialogo: -m: Es el parámetro que usará normalmente, sirve para crear una ventana de diálogo sin ningún atributo, es decir que todos los atributos (título, tamaño...) serán especificados en la tabla del diálogo. Ejemplo: /dialog –m midialogo mitabla -ma: Crea una ventana de diálogo sin atributos (como la anterior) pero además usa la ventana activa como “madre”, es decir que al cerrar la “ventana madre” se cerrará también la que hemos creado. Ejemplo: /dialog –ma midialogo mitabla -md: Crea un diálogo sin atributos (puesto que lleva el parámetro -m) y lo abre como ventana de escritorio (será mostrada en la barra de tareas inferior de Windows). Ejemplo: /dialog –md midialogo mitabla Una vez creado, podemos volver a usar el comando /dialog, pero esta vez para cambiar alguna de sus propiedades, y con la sintaxis: /dialog [-tsonkc] <nombre_dialogo> [atributos]



148

Y dependiendo del parámetro que especifique en [-tsonkc], usaremos unos atributos u otros (o a veces ninguno): -x: Cierra una ventana de diálogo. Ejemplo: /dialog –x midialogo -t: Cambia el título de una ventana de diálogo. Ejemplo: /dialog –t midialogo Este es el nuevo título -s: Cambia el tamaño y la posición del diálogo en base a las coordenadas y dimensiones que se especifiquen:. Ejemplo: /dialog –s midialogo 10 20 300 400 NOTA: Recuerde la definición de “rectángulo” en el tutorial de ventanas de imagen, el ejemplo de arriba pondrá la esquina superior izquierda del diálogo en las coordenadas x(10) y(20) y le dará un tamaño de 300 pixels de largo por 400 de alto. -o: Pone el diálogo encima de todas las ventanas que tenga abiertas (on top), y sigue estando encima aunque pulse fuera de ella. Ejemplo: /dialog –o midialogo -n: Quita el atributo “on top” de un dialogo, es decir que ya no estará permanentemente encima de todas las ventanas. Ejemplo: /dialog –n midialogo -k: Provoca el efecto de pulsar el botón “ok” de un diálogo. Por defecto, el efecto de este botón es simplemente el de cerrar el dialogo, pero más adelante veremos que le podrá asignarle más funciones. Ejemplo: /dialog –k midialogo -c: Provoca el efecto de pulsar en un boton “cancelar” de un diálogo, que por defecto es exactamente el mismo que el de un boton “ok”, pero al igual que en el anterior, se podrá modificar. Ejemplo: /dialog –c midialogo



149

Vista la creación de ventanas de diálogo, ahora el tema será como crear las ya nombradas “Tablas de diálogo” TABLAS DE DIÁLOGO Como hemos visto anteriormente en la creación de diálogos, es necesario especificar el nombre de una tabla en la que definiremos el título,tamaño y objetos que habrá en el mismo. En está sección usted aprenderá a crear tablas de diálogo revisando todas las posibilidades que nos ofrece el mIRC. La declaración de tablas de dialogo se hace en la sección Remotes, y de la siguiente forma: DIALOG <nombre_tabla> {

.......... }

Todo lo que hemos hecho es decirle al script que existe una tabla de diálogo de nombre "nombre_tabla", pero para que esta sea válida tendremos que incluir en ella la declaración de 3 cosas imprescindibles: El título del diálogo (que aparecera en la barra de título del mismo), el tamaño y posición del dialogo (en el formato x y w h ), y al menos un boton de tipo “ok” o “cancel” para cerrar el diálogo. Para ello escribiremos lo siguiente: Dialog mitabla { title “Aquí el título” size <x y w h> button “Texto_del_boton”,<ID>,<x y w h>,<estilo>

} Donde dice x y w h recuerde que ha de poner las coordenadas que definen el rectángulo al que se refiere: posición de la esquina superior izquierda del dialogo (x,y), longitud (w) y altitud (h) en pixels. Donde dice “ID” se refiere a un número que asignaremos a cada objeto que añadamos a la tabla, ese número nos servirá más adelante para referirnos a ese objeto, por lo tanto no se puede repetir la misma ID en dos objetos dentro de una misma tabla. Y por último el estilo, al tratarse de un botón, en este caso será uno de los siguientes:

• ok: Crea un boton que cierre el dialogo al pulsarlo. • cancel: Crea un boton que tambien cierra el dialogo al pulsarlo. • default: Crea un boton que no cierra el dialogo, le podremos asignar otra funcion más adelante.



150

Antes de entrar en el resto de objetos que podrá usar, veamos este pequeño ejemplo para que vaya entendiendo el funcionamiento de las tablas, copie lo siguiente en Aliases: /Dialogo { dialog –m midialogo mitabla } Copie esto otro en Remotes: dialog mitabla { title "Hola Mundo!!" size 20 20 120 100 button "¡¡Adiós!!",1,20 20 80 50,ok

} Si ahora escribe el alias (qie piede ser mediante un popups o escribiendolo en la linea de comandos) que acaba de crear: "/dialogo", verá como le aparece una ventana con el título que ha especificado y con un bóton de tipo “ok” (cierra el dialogo al pulsarlo) , las coordenadas y tamaño de la misma serán: “20 20 100 100”. A continuación veremos ya la relación de objetos que podemos declarar en una ventana de dialogo: title “Título” Como hemos visto en el ejemplo anterior, el texto que pongamos entre “ “ será el texto que salga en la barra de título del dialogo. size x y w h Indica la posición y tamaño del diálogo. Si indicamos el valor ‘-1’ para x e y, el diálogo aparecerá centrado en la pantalla. text “Texto”,ID,x y w h,estilo Pone el texto que indiquemos en las coordenadas x y w h. Recuerde que a cada objeto que ponga en el diálgo le ha de asignar un número ID, el que usted quiera para despues referirse a ese objeto más adelante. El estilo es opcional, si no se especifica ninguno el texto estará alineado a la izquierda del rectángulo “x y w h”, los estilos que puede utilizar son:

• right: para alinear el texto a la derecha. • center: para centrarlo en el rectangulo “x y w h”.



151

edit “Texto inicial”,ID,x y w h,estilo Inserta una caja de texto en el lugar indicado, con una posicion y tamaño dados en “x y w h”, y con uno de los estilos siguientes: <en_blanco> : si no especifica ningun estilo: campo de texto normal con el texto inicial alineado a la izquierda.

• right: alinea el texto inicial a la derecha. • center: centra el texto inicial. • multi: crea un campo de texto con multiples líneas, para ello ademas de especificar este estilo tendrá que hacer el campo más alto (aumentar el valor ‘h’).

• pass: útil para introducir passwords, trasforma cada carácter que escribamos en el campo en un asterisco (*).

• read: para que el campo sea solo para mostrar información al usuario, es decir que el texto que pongamos en ese campo no podrá ser modificado por el usario.

• hsbar: pone una barra de desplazamiento horizontal en la parte inferior. • vsbar: pone una barra de desplazamiento vertical a la derecha. • autohs: hace que el campo se desplaze automaticamente en horizontal cuando introduzcamos un texto que ocupe más que el tamaño de la caja de texto.

• autovs: hace que el campo se desplaze automaticamente en vertical cuando introduzcamos un texto que ocupe más que el tamaño de la caja.

button “Texto del boton”,ID,x y w h,tipo Crea un botón en cuyo interior ponga el texto que especifiquemos, y lo posiciona en las coordinadas x,y con un tamaño de ‘w’ pixels de largo por ‘h’ de alto. Los tipos posibles son:

• ok: Al pulsar el botón se cerrará el diálogo. • cancel: Al pulsar el botón se cerrará el dialogo. • default: Al pusar el botón no se cierra el diálogo, especificaremos la funcion de este tipo de botones más adelante.

check “Texto”,ID,x y w h,estilo Crea un botón “checkbox” o botones de selección de opciones (sirven principalmente para activar/desactivar algo) en las coordenadas y con el texto especificado. Los estilos posibles son:

• right: el texto se coloca a la derecha del checkbox.



152

• left: el texto se coloca a la izquierda del checkbox. • 3state: pone un checkbox de 3 estados (pulsado, no pulsado, e intermedio). • push: pone un tipo especial de checkbox que en vez de con casillas pulsables, se hace mediante botones que permanecen pulsados.

radio “Texto”,ID,x y w h,estilo Crea un botón de radio (sirven para elegir entre una entre varias opciones) en las coordinadas “x y w h” y con el texto “Texto”. Los estilos posibles son:

• right: el texto se coloca a la derecha del boton de radio. • left: el texto se coloca a la izquierda del boton de radio. • push: pone un tipo especial de boton de radio hecho a base de botones estandar.

box “Titulo”,ID,x y w h Crea un rectángulo con el titulo, posicion y tamaño especificados, se sule usar para enmarcar grupos de objetos, por ejemplo grupos de botones de radio. list ID,x y w h,estilo Crea una lista de objetos en las coordinadas especificadas (siempre relativas a la ventana de diálogo) en la que se podrán elegir uno o mas objetos a la vez de la lista dependiendo del estilo. El cómo añadir mas objetos a la lista lo veremos más adelante. Los estilos posibles son: <en_blanco>: si no especificamos estilo, se crea una lista en la que solo podemos seleccionar un objeto a la vez y el orden de estos será el mismo en que los añadamos mas adelante.

• sort: Ordena los objetos de la lista por orden alfabético. • extsel: Permite seleccionar varios obajetos de la lista a la vez.

combo ID,x y w h,estilo Crea una lista de objetos en la que solo se podrá elegir uno de ellos, en las coordenadas especificadas. Los estilos posibles son:

• sort: ordena los objetos de la lista por orden alfabético. • edit: pone una editbox arriba de la lista. Al pulsar en un objeto de la lista éste aparece en la editbox y puede ser editado.

• drop: pone un recuadro en el que al pulsar aparecerá la lista de objetos.



153

icon ID,x y w h,[archivo] Inserta una imagen en formato .bmp en las coordenadas que indiquemos. Si los valores ‘w’ y ‘h’ no coinciden con el tamaño de la imagen, ésta será estrechada o ensanchada al tamaño que hayamos especificado, el parámetro archivo no hace falta especficarlo ahora, lo podrá hacer más adelante. Hasta aquí todos los objetos que puede poner en un diálogo. Adicionalmente a los estilos que se han comentado, cualquier objeto puede además contar con los siguientes:

• disable: Inabilita en objeto. • hide: Esconde el objeto. • group: Indica el comienzo de un grupo, útil para marcar el comienzo de un grupo de botones de radio, para ello en el primer botón del grupo indicaremos el estilo “group”.

• result: Indica que el contenido de este objeto será el resultado que devuelva el dialogo al pulsar el boton “ok”. Solo se usa cuando el diálogo lo abrimos mediante el identificador $dialog (explicado má adelante).

Una cosa importante que debe saber es que se pueden especificar VARIOS estilos a la vez con solo ponerlos separados con comas, por ejemplo: edit “Texto”,4,10 10 100 20,autohs,right NOTA: En la declaración de objetos puede usar variables, es decir podrá, por ejemplo, mostrar en un campo de texto el valor de una variable. Ya hemos visto todos los tipos de objetos que podrá usar a la hora de crear una tabla de diálogo, por supuesto no usará todos estos tipos en el mismo diálogo, aunque podría hacerlo si quisiera... antes de seguir vamos a hacer un ejemplo de una ventana algo más complicada ya que con lo que sabemos hasta ahora es posible crear la interfaz gráfica de cualquier ventana de diálogo imaginable, lo próximo será proporcionar funcionabilidad a cada uno de los objetos... pero antes, lo dicho, vamos a un ejemplo: Copie lo siguiente en Aliases: /Dialogo2 { dialog –m dialogo2 mitabla2 } Y ahora copie lo siguiente en Remotes: dialog mitabla2 { title "Qué información se muestra dónde" size 30 30 330 260



154

box "Mostrar información",1,10 10 150 100 radio "En Status",2,20 30 130 20,right,group radio "En Ventana aparte",4,20 80 130 20,right box "Otras opciones",5,170 10 150 100 check "Mostrar Nombre",6,180 30 130 20,push check "Mostrar E-Mail",7,180 55 130 20,push check "Mostrar Web",8,180 80 130 20,push box "Datos",9,10 115 310 100 text "Su Nombre:",10,20 135 100 20 text "Su E-Mail:",11,20 160 100 20 text "Su Web:",12,20 185 100 20 edit "",13,100 135 180 20 edit "",14,100 160 180 20 edit "",15,100 185 180 20 button "Mostrar Información",16,40 225 130 25,ok button "Cancelar",17,190 225 90 25,cancel

} No se va a comentar el código línea por línea puesto que sería repetir lo ya explicado, pero una vez leído y probado (usando el alias "/dialogo2" ) se debe haber dado cuenta de unas cosas importantes:

• Cada objeto tiene su ID, en este ejemplo se van numerando de 1 a N siendo ‘N’ el numero total de objetos, de esa forma más adelante nos será más facil acordarnos de la ID de un objeto.

• Cuando el texto inicial de, por ejemplo, un campo de texto queremos que sea nulo, es decir, que no haya texto inicial, se especifican las comillas vacías “”.

• Al pulsar en uno de los botones de radio, el resto quedan sin pulsar, esto se ha conseguido indicando en el primero de ellos el estilo “group”. Si hubiera otro grupo de botones de radio en otra seccion del diálogo haríamos lo mismo, indicaríamos en el primer boton el estilo group.

• El uso de “box” da un aspecto más agradable al diálogo, su uso esta muy recomendado para encuadrar objetos del mismo tipo o tema.



155

El identificador $dialog Este identificador puede ser usado de varias maneras. Si en una tabla de un diálogo especificamos en unos de los objetos el estilo “result”, y después creamos un diálogo usando este identificador, el valor que nos devolverá el identificador será el mismo que el de ese objeto cuyo estilo es “result”. Para crear un diálogo con este identificador usaremos la sintaxis: $dialog(<nombre_dialogo>,<nombre_tabla>) Pero por supuesto siendo un identificador no puede usarse independientemente (como si fuera un comando) puesto que devuelve un valor que debemos de recojer, lo tendremos que utilizar para darle un valor a una variable, por ejemplo: %resultado = $dialog(midialogo,mitabla) También podemos usar este identificador sencillamente para obtener el nombre de los diálogos abiertos en este momento, para ello usaremos la sintaxis: $dialog(<nombre_dialogo>/<N>) Devolverá el número de diálogo en caso de que especifiquemos un nombre, o el nombre del diálogo abierto numero <N> en caso de que optemos por especificar ese parámetro. Ejemplo: %variable = $dialog(3) Le da a %variable el valor del nombre del tercer diálogo que tengamos abierto en ese momento. Y el último uso del identificador $dialog es para recoger información general de un diálogo, como su tamaño o su título:

• $dialog(<nombre>).x: Devuelve la posición en el eje X del diálogo. • $dialog(<nombre>).y: Devuelve la posición en el eje Y del diálogo. • $dialog(<nombre>).w: Devuelve la longitud en pixels del diálogo. • $dialog(<nombre>).h: Devuelve la altitud en pixels del diálogo. • $dialog(<nombre>).title: Devuelve el título del diálogo. • $dialog(<nombre>).modal: Devuelve $true si el diálogo ha sido creado con el identificador $dialog, o $false si el diálogo ha sido creado con el comando /dialog.

• $dialog(<nombre>).table: Devuelve el nombre de la tabla que está usando el diálogo.

• $dialog(<nombre>).ok: Devuelve la ID del botón con estilo “ok”. • $dialog(<nombre>).cancel: Devuelve la ID del botón con estilo “cancel”. • $dialog(<nombre>).result: Devuelve la ID del botón que tenga como estilo “result”.



156

EL COMANDO /did Una vez abierta una ventana de diálogo lo normal es que queramos modificar algo, quizas queramos añadir texto a un campo de texto, o poner una variable en éste, para ello usaremos el comando /did que sirve para modificar una ventana de diálogo que ya está abierta. La sintaxis es: /did [–ftebvhnmcukradiog] <nombre_dialogo> <id> [N] [texto/archivo] Y a continuación la explicación de los diferentes parámetros que podemos usar con este comando: -f: Enfoca el objeto <id>. Ejemplo: /did –f midialogo 20 -t: Hace que el bóton <id> sea el bóton por defecto (su funcion se producirá tambien al pulsar ENTER). Ejemplo: /did –t midialogo 23 -b: Hace que no se pueda interactuar con el objeto <id>. Ejemplo: /did –b midialogo 12 -e: Devuelve la interacción al objeto <id>, en caso de que se le hubiera quitado con el parámetro anterior. Ejemplo: /did –e midialogo 16 -v: Hace que el objeto <id> sea visible. Ejemplo: /did –v midialogo 10 -h: Esconde el objeto <id> (lo hace invisible). Ejemplo: /did –h midialogo 10 -m: (Sólo funciona en campos de texto) Hace que el texto NO sea editable. Ejemplo: /did –m midialogo 30 -n: (Sólo funciona en campos de texto) Deshace el parámetro anterior, es decir el texto ya se puede editar en el campo de texto. Ejemplo: /did –n midialogo 29 -c: Activa un checkbox o boton de radio (para ello NO se especifica [N] ), o selecciona la linea N en una lista de objetos. Ejemplo: /did –c midialogo 13 5 -u: Desactiva un checkbox o boton de radio (no se especifica [N]), o la linea [N] en una lista de objetos deja de estar seleccionada. Para marcar un checkbox como indeterminado (en caso de que sea de estilo 3state) usaremos los parámetros [-cu] a la vez. Ejemplo: /did –u midialogo 2 -k: (Sólo funciona en listas de objetos) Al usarse junto con los parámetros [-c] o [-u] hará que se mantenga la selección que ya había y añada o quite a ésta la que acabamos de hacer. Ejemplo: /did –ck midialogo 4 2 -r: Borra todo el texto del objeto <id> (usado generalmente para campos de texto). Ejemplo: /did –r midialogo 3 -a: Añade una línea de texto al final de la que ya haya en el objeto <id>. Ejemplo: /did –a midialogo 6 %variable -d: Borra la linea [N] de texto de un objeto. Ejemplo: /did –d midialogo 8 2



157

-i: Inserta una linea de texto en la posición [N]. Ejemplo: /did –i midialogo 10 2 Insertando entre 2ª y 3ª linea -o: Sobreescribe la linea [N] con el texto especificado. Ejemplo: /did –o midialogo 10 1 Sustuimos la linea uno por este textpo -g: Pone una imagen .bmp a un objeto de icono. Ejemplo: /did –g midialogo 10 c:\imagen.bmp Vistas ya las formas para crear un a ventana de diálogo y modificarla a nuestro gusto, y antes de entrar a ver el evento ON DIALOG que nos servirá para asignarle ciertas funciones a cada objeto, veamos un par de identificadores propios de los diálogos que nos serán muy útiles para recoger información de las ventanas que creemos.

El identificador $did Este otro identificador nos servirá para recoger información de los objetos de un diálogo. sus posibles usos son:

• $did(<nombre>,<id>).text: Devuelve el texto del objeto <id>. • $did(<nombre>,<id>,<N>).len: Devuelve la lingitud en caracteres de la linea <N> del objeto <id>.

• $did(<nombre>,<id>).lines: devuelve el numero total de lineas del objeto <id>.

• $did(<nombre>,<id>).sel: Devuelve el número de la linea seleccionada. • $did(<nombre>,<id>).state: Devuelve el estado del objeto <id> ( 0 = off ; 1 = on; 2 = indeterminado).

• $did(<nombre>,<id>).next: Devuelve la id del próximo obejto en el orden del tabulador.

• $did(<nombre>,<id>).prev: Devuelve la id del objeto previo en el orden del tabulador.

Una vez aprendidos estos identificadores, aparte de saber crear y modificar ventanas, tan solo nos falta el último paso, el decirle a determindo control que ejecute determinados comandos, decirle a determinado campo de texto que ponga su contenido dentro de determinada variable,... etc. Esto se consigue con un evento remoto, el ON DIALOG, que a continuación se expone con detalle.



158

EL EVENTO "ON 1:DIALOG" Este es el evento que se usará para controlar la funcionabilidad del dialogo, la sintaxis es la siguiente: on 1:dialog:<nombre_dialogo>:<evento>:<id>:{ comandos } En seguida se explicará la sintaxis anterior, antes debe saber que mediante el evento ON DIALOG usted podrá:

• Hacer que se ejcuten los comandos que usted quiera al pulsar sobre cada uno de los botones del diálogo.

• Asignar a las variables mostradas en campos de texto, el valor que el usuario indique en ese campo.

• Inicializar campos de texto u otros objetos con la posibilidad de poder usar variables si no lo ha hecvho al declarar la tabla.

• Asignar funciones a ciertos objetos cuando se produzca un doble click sobre los mismos.

• El identificador $dname se puede usar dentro del evento y devolverá el <nombre_diálogo>.

• El identificador $did se puede usar dentro del evento y devolverá la ID del objeto que haya causado el evento.

• El identificador $devent se puede usar dentro del evento y devolverá el <evento>.

Pasemos a analizar, por tanto, cuales son las variantes del evento ON DIALOG: on 1:dialog:<nombre_dialogo>:INIT:0:{ ...comandos... } Se ejcutan los comandos que especifiquemos justo antes de mostrar el dialogo en pantalla, es decir que usaremos este evento para inicializar ciertos objetos, por ejemplo si queremos poner el contenido de una variable en un campo de texto, lo haremos en este evento mediante un /did –a <nombre_dialogo> <%variable>. on 1:dialog:<nombre_dialogo>:SCLICK:<id>:{ ...comandos... } Se ejecutan los comandos especificados cuando se produce un click sobre el objeto con la id indicada. Ejemplo: on 1:dialog:midialogo:sclick:3:{ %variable = 0 }



159

on 1:dialog:<nombre_dialogo>:DCLICK:<id>:{ ...comandos... } Se ejecutan los comandos especificados cuando el usuario haga un doble click sobre el objeto de la <id> especificada. Ejemplo: on 1:dialog:midialogo:dclick:3:{ echo –s Doble click sobre objeto $did } on 1:dialog:<nombre_diálogo>:EDIT:<id>:{ ...comandos... } Se ejecutan los comandos cada vez que el usuario introduce o borra un carácter de una caja de texto. Ejemplo: on 1:dialog:midialogo:edit:5:{ %variable = $did(5).text Bien, hasta aquí el manual de ventanas de diálogo, no son realmente complicadas, sobre todo si se compara con la dificultad de hacer una ventana de este tipo mediante ventanas de imagen. Por último vamos a acabar el ejemplo que iniciamos en una de las primeras secciones de este documento, sólo que esta vez podremos acabarlo y darle toda su funcionabilidad con lo que hemos aprendido: Ejemplo : Creación de un Diálogo con toda su funcionabilidad. Antes que nada recordemos el código que ya escribimos: Copie lo siguiente en Aliases: /Dialogo2 { dialog –m dialogo2 mitabla2

} Y ahora copie lo siguiente en Remotes: dialog mitabla2 { title "Qué información se muestra dónde" size 30 30 330 260 box "Mostrar información",1,10 10 150 100 radio "En Status",2,20 30 130 20,right,group radio "En Ventana aparte",4,20 80 130 20,right box "Otras opciones",5,170 10 150 100 check "Mostrar Nombre",6,180 30 130 20,push check "Mostrar E-Mail",7,180 55 130 20,push



160

check "Mostrar Web",8,180 80 130 20,push box "Datos",9,10 115 310 100 text "Su Nombre:",10,20 135 100 20 text "Su E-Mail:",11,20 160 100 20 text "Su Web:",12,20 185 100 20 edit "",13,100 135 180 20 edit "",14,100 160 180 20 edit "",15,100 185 180 20 button "Mostrar Información",16,40 225 130 25,ok button "Cancelar",17,190 225 90 25,cancel

} Este código ya ha sido visto anteriormente así que doy por hecho que ya lo entiende. Lo siguiente que haremos será declarar en la sección Remotes una serie de eventos ON DIALOG para asingarle nuevos valores a esas variables (según lo desee elusuario) y despues para implementar la función del botón “Mostrar información”. Copiemos lo siguiente en la sección “Remotes”: on 1:dialog:dialogo2:init:0:{ if (%mostrar.donde == status) { did -c dialogo2 2 } if (%mostrar.donde == aparte) { did -c dialogo2 4 } if (%mostrar.nombre == si) { did -c dialogo2 6 } if (%mostrar.email == si) { did -c dialogo2 7 } if (%mostrar.web == si) { did -c dialogo2 8 } did -a dialogo2 13 %sunombre did -a dialogo2 14 %suemail did -a dialogo2 15 %suweb

} En el evento INIT inicializaremos el dialogo, es decir, que si la variable %mostrar.donde vale status, se activará el botón de radio correspondiente, lo mismo pasa con los checkbox, que son activados por código puesto que las ventanas de dialgoo aparecen con todos sus objetos desactivados a no ser que se especifique lo contrario. Por último se pone el contenido de las variables del nombre, email y web en sus campos de texto correspondientes:



161

on 1:dialog:dialogo2:sclick:2:{ %mostrar.donde = status } on 1:dialog:dialogo2:sclick:4:{ %mostrar.donde = aparte } Con ese código haremos que según pulse el usuario el un botón de radio u otro la variable %mostrar.donde cambie y así podamos saber despuéss donde quiere mostrar el usuario la informacion, puesto que quedará almacenado en dicha variable. on 1:dialog:dialogo2:sclick:6:{ %mostrar.nombre = $iif(%mostrar.nombre == si,no,si) } on 1:dialog:dialogo2:sclick:7:{ %mostrar.email = $iif(%mostrar.email == si,no,si) } on 1:dialog:dialogo2:sclick:8:{ %mostrar.web = $iif(%mostrar.web == si,no,si) } Este otro trozo hará que según el usuario clickee sobre los checkbox estos activen o desactiven la variable según su posición anterior, de ahí el uso del identificador $iif, que devolverá la primera opción si la condición se cumple, y en caso contrario devolverá la segunda opción siendo $iif(condicion,1ªopcion,2ªopcion). on 1:dialog:dialogo2:sclick:16:{ if (%mostrar.donde == aparte) {

window –a @Informacion 100 10 300 200 if (%mostrar.nombre == si) { aline @Informacion Nombre: %sunombre } if (%mostrar.email == si) { aline @Informacion E-Mail: %suemail } if (%mostrar.web == si) { aline @Informacion Web: %suweb }

} else { if (%mostrar.nombre == si) { echo –s Nombre: %sunombre } if (%mostrar.email == si) { echo –s E-Mail: %suemail } if (%mostrar.web == si) { echo –s Web: %suweb } }

} En este trozo hemos especificado la conducta que esperamos del boton “Mostrar Información” cuando sea pulsado, a pesar de la cantidad de líneas es un código muy simple y se limita a comprobar el valor de la variable %mostrar.donde para



162

averiguar donde quiere el usuario mostrar la informacion, y después comprueba si están activadas las variables %mostrar.nombre, %mostrar.web y %mostrar.email: para motrar o no esa información. on 1:dialog:dialogo2:edit:13:{ %sunombre = $did(13).text } on 1:dialog:dialogo2:edit:14: { %suemail = $did(14).text } on 1:dialog:dialogo2:edit:15:{ %suweb = $did(15).text } Por último le tenemos que decir al script que cuando el usuario edite los campos de texto 13,14 y 15 asigne el texto de esos campos como valor a sus respectivas variables, para que después puedan ser mostradas. Bien, si ha llegado hasta aquí, ya debe ser un pequeño experto en este tema, en este tutorial se han tocado detalladamente todos los aspectos de las ventanas de diálogo, espero que haya aprendido de él.



163

AAAGGGRRRAAADDDEEECCCIIIMMMIIIEEENNNTTTOOOSSS Es importante poner las cosas en su justo lugar y es por esto que agradezco los aportes y material para este manual, de las siguientes personas :

• Somatic • Intercom • Byte • Roman Soft • Tempest (el viejo marino del Hispano) • Rusty • Sarrio • Estepario (aunque no lo sepa)

Y a muchos otros que sin saberlo, me han aportado importantes ideas, durante las largas sesiones de IRC. GRACIAS!!!!!! y este Manual es para Ustedes.

[ESpEcIaL[De]^[JaMon]^

www.geocities.com/especial_de_jamon

mirc scripting (especial de jamon)

Documents

identificadores de tiempo

identificadores de archivos

identificadores de nick

identificadores de ventanas

identificadores diversos

comandos de mirc

mirc manual de scriptig

fmbre srt t