GUA DE RUBY

en base a

RPG MAKER XP
(RGSS)
por nemus

-2-

Prlogo
Este tutorial est dedicado a todos aquellos que quieran iniciarse en el mundo de la programacin en Ruby orientado a RPG Maker XP, o lo que tambin es llamado RGSS (Ruby Game Scripting System: Sistema de Programacin para Juegos en Ruby). Antes de poner los contenidos aviso dos cosas: La primera, que esto no es una gua exhaustiva de programacin en RGSS, y que es posible que contenga errores, por lo cual, tras terminar de leer esta gua recomendara mirar cdigos para comprender mejor las cosas. La segunda es que no le resulta igual de fcil a todo el mundo programar, as que, si pasa el tiempo y no consiguen nada, no se desesperen, la constancia casi todo lo puede. A todos aquellos que, al intentar programar ven una pgina de cdigos y no comprenden, les comunico que Ruby es un lenguaje de programacin de nivel alto, y por tanto es muy similar al lenguaje humano. Como casi todos los lenguajes de programacin, se basa en el ingls para sus comandos, por lo que, unos bsicos conocimientos de ingls nos ayudarn. De todas maneras, en este tutorial se explica que significa, traducido al espaol, los comandos de habla inglesa. Por ltimo, comentarles que la programacin es un sistema muy bueno de potenciacin del cerebro, ayuda a la ramificacin del mismo y a mejorar sus interconexiones. Es decir, mejora su funcionamiento y potencia la velocidad de pensamiento. Ahora comienzo con el tutorial, les deseo suerte con su aprendizaje. Si tienen alguna duda, contacten conmigo desde esta pgina (bien desde los foros o desde la seccin contacta de la misma). http://anemusint.byethost7.com/ Gracias por confiar en este tutorial,

nemus

-3-

ndice
Introduccin ....................................................................................................... Pg. 4 Entender el Sistema de colores del editor......................................................... Pg. 4 Operadores matemticos .................................................................................. Pg. 4 Variables............................................................................................................ Pg. 5 4.1. Introduccin................................................................................................. Pg. 5 4.2. Tipos segn su duracin ............................................................................. Pg. 5 4.3. Nmeros...................................................................................................... Pg. 6 4.4. Textos.......................................................................................................... Pg. 6 4.5. Booleanos ................................................................................................... Pg. 7 4.6. Arrays .......................................................................................................... Pg. 8 4.7. Tablas (Hash Tables).................................................................................. Pg. 8 4.8. Objetos ........................................................................................................ Pg. 8 5. Print ................................................................................................................... Pg. 9 6. Grficos ............................................................................................................. Pg. 10 6.1. Sprites ......................................................................................................... Pg. 10 6.2. Incrustados en ventanas ............................................................................. Pg. 11 6.3. Puntos y Lneas .......................................................................................... Pg. 12 7. Condicionales .................................................................................................... Pg. 13 7.1. If .................................................................................................................. Pg. 13 7.2. Unless ......................................................................................................... Pg. 14 7.3. Case ............................................................................................................ Pg. 14 8. Bucles ................................................................................................................ Pg. 15 8.1. For ............................................................................................................... Pg. 15 8.2. Next ............................................................................................................. Pg. 15 8.3. Loop do ....................................................................................................... Pg. 16 8.4. Break .......................................................................................................... Pg. 16 8.5. While ........................................................................................................... Pg. 16 9. Operadores lgicos > And Or Not ..................................................................... Pg. 17 10. Nmeros Aleatorios ........................................................................................... Pg. 18 11. Clases................................................................................................................ Pg. 20 11.1. Introduccin................................................................................................. Pg. 20 11.2. Definicin de clases y llamada.................................................................... Pg. 20 11.3. Mtodos de clase ........................................................................................ Pg. 20 11.4. Parmetros en los mtodos de clase.......................................................... Pg. 21 11.5. Superposicin de mtodos de clase ........................................................... Pg. 21 11.6. Frmulas de acceso a variables de una clase (attr) ................................... Pg. 22 11.7. Superposicin de clases ............................................................................. Pg. 22 11.8. Alias............................................................................................................. Pg. 22 11.9. Subordinacin de clases ............................................................................. Pg. 23 11.10. Clases-Ventana (Windows) ..................................................................... Pg. 24 11.11. Clases-Ventanas de comandos (Window_Selectables).......................... Pg. 25 11.12. Clases-Escena (Scenes) ......................................................................... Pg. 26 12. Clases ms importantes ....................................................................................... Pg. 28 12.1. Window_Base ............................................................................................. Pg. 28 12.2. Interpreter.................................................................................................... Pg. ?? 12.3. Scenes ...................................................................................................... Pg. ?? 12.4. Windows .................................................................................................... Pg. ?? 12.5. Games ........................................................................................................ Pg. ?? 12.6. Main (no es una clase)................................................................................ Pg. 29 1. 2. 3. 4.

-41. Introduccin
El sistema de programacin del RPG Maker XP es Ruby, y se encuentra en los llamados scripts. Para acceder a los scripts pulsa F11 durante la edicin del juego, para que te salga la pantalla de scripts. A la derecha estn las pginas, y a la izquierda los contenidos de las mismas. Las pginas no son necesarias, pero, para mayor orden se recomienda que vaya una clase por pgina (ya explicar que es eso de clases), y que dicha pgina lleve el nombre de la clase, auque no es necesario, pero ayuda a encontrar cosas. El Ruby es un lenguaje de programacin orientado a objetos, es decir, que usa objetos para funcionar. Este sistema es uno de los ms rpidos, ya que hace que haya menos lneas de cdigo haciendo que no sean necesarias las definiciones de variables (ms abajo explicadas) y algunas otras cosas. Ruby posee la funcin de la identificacin de maysculas y minsculas, por lo que podemos definir una variable @hola, y otra @HOLA, que sern distintas. Tambin sucede con los comandos. No reconocer IF, ni If, ni iF, pero si if. Los comandos siempre en minscula a no ser que se especifique lo contrario.

2. Entender el sistema de colores del editor

Azul oscuro: definiciones, clases y operadores lgicos (if, for, case), las referencias a objetos self, super y el valor nulo nil, y las constantes booleanas true y false NO ADMITEN MAYSCULAS. De todas maneras, ningn comando que se explique en este tutorial que vaya con minsculas se aceptar con maysculas. Hay unos pocos comandos que llevan maysculas, y solo sern reconocidos con esas maysculas. Granate: nmeros Azul claro: operadores matemticos, puntos, parntesis Verde: Reminders, notas, no se ejecutan, sirven para que lo leas, como anotaciones para decir que aqu va algo, y que es. Se ponen con # Morado (entre comillas): Son textos. Se usan para las variables de texto (string), imprimir mensajes, el nombre de archivos Negro: Nombres de variables, clases, definiciones, propiedades de clases, y el comando print (para mandar mensajes de error) Hay muchas palabras nuevasno se desanimen, se explicarn.

3. Operadores matemticos
Son utilizados en las operaciones matemticas. Suelen ser parecidos a nuestra forma de expresar las matemtica. + : signo de suma - : signo de resta * : signo de multiplicacin / : signo de divisin ** : signo de potenciacin % : signo de resto de divisin

-5-

Hay algunas operaciones que no estn disponibles de forma tan simple, como el porcentaje o la raz. Ahora vienen explicadas: Raz: se usa la potenciacin de la siguiente manera: num** (1/raiz), siendo raiz el valor del exponente de la raiz que deseamos hacer (raz cuadrada 2, raz cbica 3 Porcentaje: se multiplica el valor por el nmero del porcentaje que se desea obtener, y se divide por cien (num* porcentaje/100). Tambin hay formas de abreviar algunas operaciones. Por ejemplo, estamos dando a una variable num su mismo valor sumndole 5, pues se escribira de esta manera siguiendo el cdigo normal: :: Cdigos :: num = num + 5 Pero se puede abreviar en la siguiente sentencia: :: Cdigos :: num += 5

Ruby tambin tiene la opcin de usar decimales, solo se ha de aadir a uno de los trminos de la operacin matemtica, una coma y tantos ceros como decimales quieres que use. Recomiendo no pasarse con los ceros.

4. Variables
4.1 Introduccin Las variables de Ruby, son auto definidas (no hay que definirlas) y su tipo de valor es variable (igual pueden contener un nmero como un booleano (true, false)). A pesar de que sean variantes, no se puede decir, ahora eres de texto, ahora de nmero, para ello hay que definirlas nulas (vaciarlas /formatearlas) con la sentencia siguiente: :: Cdigos :: variable = nil Es preferible no usar maysculas (se puede) pero si usas maysculas y luego te refieres a la variable sin dichas maysculas, no funciona. Es decir: si t defines la variable Hola, y te refieres a ella mas tarde como hola, no funcionar.

4.2 Tipos segn su duracin Hay tres tipos de variables en orden a su duracin: Globales: se inician cuando son llamadas por primera vez, y se terminan cuando se cierra el programa. Se usaran para variables que no queremos que pierdan nunca su valor mientras el juego est activo. Para que el valor se guarde en un archivo se usar una sentencia que explicar mas tarde. Se diferencian en que son introducidas por el smbolo del dlar $.

-6 De Clase: se inician cuando son llamadas, y se terminan cuando la clase donde fueron llamadas se termina o vaca. Se diferencian en que son introducidas por el carcter del arroba @. De Mtodo: se inician cuando el mtodo se inicia, y se terminan cuando se sale del mtodo. No funcionan fuera de dicho mtodo. No van introducidas por ningn carcter.

4.3 Nmeros Las variables numricas se caracterizan por contener un nmero. Puede ser un entero desde unos 2 billones a menos ese mismo nmero. Pero tambin puede tener comas. Para definir una variable numrica has de darle un valor numrico a una variable liberada (cuyo valor es nil o no ha sido definida (segn su nivel (global, de clase o de mtodo)) :: Cdigos :: num = 5

OPERACIONES :: Cdigos :: m = 1 m += 1 m -= 1 m *= 2 m /= 2 #=>equivale a m = m + 1 #=>m = m 1 -> 1 -> 2

#=>m = m * 2

#=>m = m / 2 -> 1

Mtodos .chr: devuelve al carcter ASCII correspondiente al nmero Para ver el cdigo ASCII puedes hacerlo http://ascii.cl/es/. .empty? : devuelve true si la variable est vaca. .to_s: lo convierte en una cadena de texto.

4.4 Textos Las variables String contienen una cadena de texto. :: Cdigos :: #esta variable string no contiene texto, pero es de texto @variablestring1 = #esta variable string contiene un texto @variablestring2 = Hola a todos!

No puedes convertir directamente una variable de nmero en una de texto, para ello usa la siguiente sentencia:

-7-

:: Cdigos :: #esta es una variable de nmero @numero = 10 #esta es una variable de texto @texto = #{@numero} #esta variable tendr el valor del triple de @nmero @texto = #{@numero *3} Para unir dos variables de texto se usa el comando + entre las dos variables a sumar. :: Cdigos :: str1 = Hola, str2 = Qu tal? #esta variable de texto contendr la unin de las cadenas de #texto str1, y str2. @texto = str1 + str2 #ahora @texto contiene Hola, Qu tal?

Mtodos .size: nos devuelve el nmero de caracteres que tiene la cadena. .upcase: las letras se muestran maysculas. .downcase: las letras se muestran en minsculas. .gosub (patrn) {comando}: busca un patrn en el texto y ejecuta un comando. .insert (caracter, insercin): inserta un texto tras el carcter seleccionado. .empty? : devuelve true si la variable est vaca. .include? (string): devuelve true si la cadena string est en el texto donde se aplica este mtodo. .delete (string): elimina una cadena de texto string del texto donde se aplica este mtodo.

4.5 Booleanos Son variables que slo pueden adquirir 2 valores: true (verdadero, si, 1) o false (falso, no, 0). Su nombre viene de un matemtico llamado Boole, que invent una rama de las matemticas que se dedica a estudiar si es verdad o no. Se emplean con el llamado lgebra de boole, que aunque no es necesario conviene conocer. Se emplea con ceros y unos (como si fuera binario) pero aqu, para evitar los voy a sustituir el cero por el false y el uno por el true. Propiedades bsicas de lgebra de boole: Suma: true + false = true; true + true = true; false + false = false Multiplicacin: true * false = false; true * true = true; false * false = false Negacin: true (negado) = false; false (negado) = true El lgebra de boole es algo ms extenso y complicado, pero ocupara demasiado para incluirlo aqu. Mas adelante esto ser bastante til, cuando veamos los condicionales.

-84.6 Arrays Son variables excepcionales que pueden contener ms de un valor en su interior. Para poder usarlas hay que definirlas como arrays con: :: Cdigos :: array = [ ] #dentro de los corchetes pueden entrar algunas #ordenes como estas, #pero no es necesario para definirla. array2 = [hola, qu tal?, adis]

Los arrays pueden contener objetos tambin. Y como cosa excepcional, pueden contener ms de un tipo de valor: :: Cdigos :: array3 = [hola, 10, true] Mtodos .clear: vaca la variable. .compact: al usarlo junto a la variable, devuelve el Array sin espacios vacos .compact: borra todos los espacios vacos. .include? () busca un valor u objeto situado en los parntesis. Devuelve un true o un false. .push(): incluye como ltimo elemento del array lo que halla en los parntesis.

4.7 Tablas (Hash Tables) Tambin llamados Arrays Asociativos, este tipo excepcional de array permite relacionar una clave con un valor, en vez del ndice de los Arrays. Para poder usar un array asociativo necesitamos definirlo como tal aadindole una clave con su valor o diciendo que queremos que sea un array asociativo. :: Cdigos :: hash = { } #dentro de las llaves pueden entrar algunas #asociaciones, pero no es necesario para definirla. array2 = {Valor 1=>12, Valor 2=>3} # el vnculo de asociacin es => La llamada a los valores de un array asociativo se realiza de la siguiente manera: :: Cdigos :: print hash [Valor 1] # Mostrar 12 print hash [Valor 2] # Mostrar 3 print hash [Hola] # Mostrar nil Mtodos: .delete (string): elimina la clave que equivalga al valor del parmetro, y con ella su valor. .keys: devuelve un array normal con las claves. .values: devuelve un array normal con los valores.

-9-

4.8 Objetos Las variables tambin pueden contener objetos, los cuales se definen en clases (class). Hay una serie de variables objeto globales muy importantes en el desarrollo del juego y que deben de ser conocidas para su correcta utilizacin: $scene: contiene la clase de escena que se muestra en el preciso instante. Si por ejemplo estamos en el men de objetos, la variable $scene contendr el objeto Scene_Items. $data_actors: contiene a los actores o personajes principales del juego. $data_items: contiene los datos de los objetos utilizables. $data_weapons: contiene los datos de las armas. $data_armors: contiene los datos de los protectores y accesorios. $data_skills: contiene los datos de las habilidades. $data_animations: contiene los datos de las animaciones. $data_troops: contiene los datos de los grupos de enemigos. $data_classes: contiene los datos de las profesiones. $data_enemies: contiene los datos de los enemigos. $data_states: contiene los datos de los estados. $data_tilesets: contiene la informacin de los tiles. $data_comon_events: contiene la informacin sobre los eventos comunes. $data_system: contiene la informacin del sistema. :: Notas :: Todos las variables globales $data se cargan en el mtodo main de la clase Scene_Title, y hay que mencionar que no son objetos simples, si no arrays que contienen objetos. De tal manera que si queremos acceder a uno tendremos que poner su index. Tambin mencionar que las variables $data_... contienen puramente datos. $game_system: contiene la clase Game_System, contiene variables del sistema. $game_temp: contiene la clase Game_Temp, contiene variables temporales, como el formato de batalla u otras cosas. $game_switches: contiene la clase Game_Switches, contiene los interruptores del juego. Se accede a ellos de la siguiente manera: $game_switches[id] = true. Como veis, es un Array. $game_variables: contiene la clase Game_Variables, que contiene las variables numricas del juego. Se accede a ellas de idntica manera que los interruptores. Es un Array. $game_self_switches: contiene la clase Game_SelfSwitches, que contiene los valores de los interruptores locales. Es un Array. $game_screen: contiene la clase Game_Screen, que contiene la pantalla a mostrar, as como las imgenes, los efectos de clima, el tono... $game_actors: contiene la clase Game_Actors, que contiene los datos de los actores que estn en el grupo. Es un Array. Cada uno de los ndices de esta variable son el cdigo de la clase Game_Actor. $game_party: contiene la clase Game_Party, que incluye los cuatro personajes que tiene el grupo, y otras caractersticas del grupo, tales como el oro, los objetos, los pasos, los protectores... $game_troop: contiene la clase Game_Troop, en la cual se incluyen llamadas a la clase Game_Enemy, y que contiene las caractersticas de los grupos de enemigos o tropas. $game_map: contiene la clase Game_Map, en la cual se incluyen las opciones de los mapas. $game_player: contiene la informacin escrita en Game_Player, y esta contiene las caractersticas del personaje principal. :: Notas :: Todas estas variables se definen en el mtodo command_new_game de Scene_Title, y se pueden modificar en las pginas de cdigos de la parte de arriba.

- 10 -

En el fondo, los tipos de variables que estudiamos antes son tambin objetos.

5. Print
Este comando sirve para enviar un cuadro de mensaje con un texto que definiremos despus: :: Cdigos :: print Buenos das! Eso mostrar un mensaje que dice Buenos das!. Tambin podemos hacer que muestre cualquier variable, sea del tipo que sea. :: Cdigos :: booleano = true print booleano numero = 12 print numero texto = hola print texto

#=> true #=> 12 #=>hola

Esto ltimo, es especialmente til en la fase de desarrollo de un script, ya que sera la nica manera de mostrar valores de forma clara, pero cuidado con ponerlo en un mtodo update, pues se repetir eternamente si no ponis un lmite. Si intentis hacer print con una variable de objeto, os mostrar la almohadilla, el nombre del objeto y una serie de valores. Existe una variante de Print llamada p, pero muestra las comillas.

6. Grficos
6.1 Sprites Para mostrar grficos, primero tenemos que definir una variable como un objeto bitmap, o Sprite, lo que no es ms que una variable objeto. :: Cdigos :: @imagen = Sprite.new Tras ello, hay que definir que sprite o imagen queremos que muestre. Para eso usamos lo siguiente: :: Cdigos :: @imagen.bitmap = ("Graphics/subcarpeta/archivo.png")

- 11 Donde pone subcarpeta hay que poner la carpeta donde se aloja. Si es un battler, la carpeta ser Battlers. Donde pone archivo ir el nombre del archivo. Hay una forma ms rpida que es usando la sentencia RPG::Cache que funciona de la siguiente manera. Se aplica sobre la propiedad bitmap del sprite que antes definimos. Tras poner RPG::Cache (son dos veces dos puntos) aadimos un punto, y el nombre de la carpeta con minsculas y en singular (quitando la s), y tras esto, entre parntesis y con comillas, el nombre del archivo sin la extensin. :: Cdigos :: @imagen.bitmap = RPG::Cache.battler("002-Fighter02") La ventaja de usar sprites, es que se pueden colocar en cualquier parte de la pantalla, y modificar su posicin con x e y (@imagen.x y @imagen.y), y con los mtodos ox y oy podemos definir el origen de la imagen (que punto de la imagen es donde se aplica que x se igual a la posicin dada). Son por tanto para escenas, como fondos e imgenes independientes. (el fondo del title es un Sprite, los battlers se usan como objetos sprite...). Esto no es lo mismo si usamos de otra manera los grficos.

6.2 Grficos incrustados en ventanas Si necesitamos un grfico que se muestre dentro de una ventana, y si esta se mueve, que el tambin se mueva, necesitamos incrustarlos. Para ello existen los Rectngulos (llamados rect). Primero definimos la imagen, no como sprite, sino como imagen dependiente:

:: Cdigos :: im = RPG::Cache.battler("003-Fighter03") Tras esto, la imagen no se mostrar, para que se muestre necesitamos crear un rectngulo donde aparecer la imagen. Con este sistema podemos seleccionar un cacho de la imagen que deseamos ver, sin tener que verla entera. Se usa con los Characters, por ejemplo en algunos mens de guardado, que mediante una operacin matemtica, hacen que se mueva. El cdigo del Rectngulo es el siguiente (recomiendo que el rectngulo sea una variable corta):

:: Cdigos :: src_rect = Rect.new(picx, picy, ancho, alto) Donde pone picx, ir la coordenada x desde donde aparecer la imagen, en picy, la coordenada y donde aparecer la imagen, y en ancho y alto el ancho y el alto. Cuando digo la coordenada donde aparecer la imagen, significa algo as como, si tenemos una imagen de 48x48, dividida en 4 sectores de 24x24, y queremos mostrar la de abajo a la izquierda, el picx ser 24, el picy ser 0 y el ancho y el alto sern 24. El ltimo paso es mostrar la imagen dentro del rectngulo:

- 12 :: Cdigos :: self.contents.blt(x, y, im, scr_rect, opacidad) En x ir la coordenada x donde se mostrar el rectngulo con la imagen dentro, en y la coordenada y, en im se pone la variable de la imagen, en scr_rect se pone el Rect que definimos antes (se puede poner como variable src_rect o como definicin Rect.new(24, 0, 24, 24)# esto es el ejemplo de antes) y por ltimo, en opacidad ir la opacidad, en un nmero de 8 bits (del 0 al 255), siendo 255 el mximo de opacidad, y 0 la invisibilidad. Si no ponemos nada en este ltimo parmetro, se usar el valor 255, es decir, opaco.

6.3 Puntos y lneas Poner un punto es fcil, y una lnea es igual. El comando es este: :: Cdigos :: self.contents.fill_rect (x, y, ancho, alto, color, opacidad) De esta manera con la x y la y, definimos la posicin del rectngulo relleno, que es lo que significa fill_rect; con el ancho y el alto definimos la altura y la anchura del rectngulo (un punto tiene ambos valores en 1); el color se define as: :: Cdigos :: Color.new =(red, green, blue, opacity) #Red=rojo, Green=verde, Blue=azul. #la opacidad es opcional, si no se pone adoptar el valor 255 (opaco) Y por ultimo queda la opacidad. Esta, como siempre, es opcional, y si no se pone adoptar el valor 255 (opaco). Para poner un punto, ancho y alto tienen que ser 1, el. Para hacer una lnea, uno de los dos ha de ser ms de 1 y el otro 1. Si le damos a los dos un valor superior a 1, nos saldr un rectngulo. Para hacer una lnea inclinada, habr que usar funciones (de matemticas) y una sentencia for. Ahora explicar en profundidad la sentencia Color.new. Existen ciertas constantes del juego que representan unos colores determinados. Estas constantes son modificables desde la clase Window_Base de los scripts. :: Cdigos :: def normal_color return Color.new(255, 255, 255, 255) end def disabled_color return Color.new(255, 255, 255, 128) end def system_color return Color.new(192, 224, 255, 255) end def crisis_color

- 13 return Color.new(255, 255, 64, 255) end def knockout_color return Color.new(255, 64, 0) end Al igual que puedes modificarlos, se pueden aadir ms. Slo hay que poner def (que indica comienzo de un mtodo), el nombre del color; en la lnea siguiente la palabra return (que devuelve al cdigo que la llam la variable que se encuentre detrs suyo) seguida de la Sentencia Color.new que explicamos antes (que contiene un color en RGBA (Rojo, Verde, Azul y Opacidad) siendo la opacidad un parmetro opcional que adopta el valor de 255 si se omite); y en la lnea siguiente la palabra end, que indica que el mtodo termina en ese punto. Con esto, un poco de imaginacin, y el paint al lado para buscar colores en RGB (Red, Green Blue (Rojo, Verde, Azul)) y para ver donde colocar cada pxel, podis hacer scripts que dibujen cosas.

7. Condicionales
7.1 If (if then else elsif end) Se corresponde con la sentencia if. Es puesta en azul oscuro, por lo que NO ADMITE MAYSCULAS. Corresponde a los condicionales humanos. Su sintaxis es esta: if comparacin acciones si se cumple else acciones si no se cumple end else no es siempre necesario, solo se usa en el caso de que queramos usar excepciones. para la comparacin necesitaremos conocer los operadores de comparacin, que son: == : igual >: mayor que < : menor que >= : mayor o igual que <=: menor o igual que !=: no es igual que Aqu pongo un ejemplo: :: Cdigos :: if @imagen !=nil #si la variable imagen no es nula print "no es nula" #muestra un mensaje diciendo que no lo es else #si la variable imagen es nula print "es nula" #muestra un mensaje diciendo que lo es end #finaliza el condicional. De esta manera se comparan dos valores y se hacen cosas distintas segn los valores.

- 14 Si se quiere aadir otro condicional cuando la primera condicin no se cumpla (cuando se ejecuta el else), se usa la sentencia elseif, que funciona como if, pero sin necesidad del end. :: Cdigos :: if @bit = 0 print "no hay seal" elseif @bit = 1 #si bit no es cero, pero es 1 print "hay seal" end Hay otra forma de condicional, mas compleja, pero mas corta, desarrollada en una sola lnea. Sirve para dar un valor a una variable, segn otros valores. variable = condicin ? valor si se cumple : valor si no se cumple Aqu pongo un ejemplo, es usado en las ventanas de objetos, para determinar la opacidad de las imgenes. :: Cdigos :: var =algo_a_comparar==un_valor ? algo es igual a un valor : nop Esto se traduce en que la variable var tendr el valor de algo es igual a un valor cuando la variable algo_a_comparar sea igual a un_valor, y si no lo es tomar el valor de nop

7.2 Unless (unless, end) Indica que lo que aparece dentro de dicho condicional solo se ejecutar si la condicin puesta no se cumple. Es lo contrario de if, pero no contiene excepciones, ya que lo que ejecuta es la excepcin al condicional. Ej: :: Cdigos :: unless i = 12 i += 1 end

7.3 Case (case, when, end) Sirve para ejecutar una accin u otra dependiendo del valor de una variable. Sustituye al if cuando hay muchos posibles valores, por lo que ahorra lneas de cdigo. Su estructura es la siguiente case variable_a_comparar when valor_uno accin en caso de que sea el valor uno when valor_dos accin en caso de que sea el valor dos ... end

- 15 Ej: :: Cdigos :: case equip_type when 0 # Brazos return $data_actors[@actor_id].weapon_fix when 1 # Escudo return $data_actors[@actor_id].armor1_fix when 2 # Casco return $data_actors[@actor_id].armor2_fix when 3 # Armadura return $data_actors[@actor_id].armor3_fix when 4 # Accesorios return $data_actors[@actor_id].armor4_fix end

8. Bucles
8.1 For (for in end) Este comando azul (NO ADMITE MAYSCULAS), es de gran utilidad: sirve para repetir una/s accin/ones un nmero de veces especificado antes, o sin especificar, es decir que se de por variables. Su estructura es la siguiente: for variable in intervalo operaciones end La variable es una variable que tendr como valor el punto del intervalo que corresponda. El intervalo puede ser,[dos puntos] primer_nmero..segundo_nmero (en intervalos matemticos sera esto [primer_nmero, segundo_nmero] Se incluyen ambos nmeros), o [tres puntos]primer_nmero...segundo_nmero ( [primer_nmero, segundo_nmero), no se incluye el ltimo nmero). Otra opcin es usar Arrays: :: Cdigos :: for i in @array acciones end En tal caso "i" adoptara el valor de cada uno de los valores de dicho array.

8.2 Next Este comando funciona de la siguiente manera: si se ejecuta dentro de una sentencia for, se produce un salto de nuevo al siguiente valor de la variable establecida.

- 16 EJ: :: Cdigos :: # queremos que haga algo 12 veces, pero que no lo #haga a la tercera for i in 0...12 # [0, 12) hay que tener en cuenta que #no coge decimales if i == 3 next #si i es tres, no ejecutar las acciones #siguientes, si no que pasar a i = 4 end operaciones end

8.3 Loop do (Loop do, end) Sirve para repetir algo indefinidamente hasta que se rompa el ciclo con break (luego lo explico). Su estructura es tan simple como: loop do acciones end A pesar de que la palabra loop no est en azul, se ha de escribir con minsculas. Desgraciadamente, el loop consume mucho, y es posible que desborde los scripts (el juego se bloquea unos segundos, y luego muestra un mensaje diciendo "Script Desbordado" y tras pulsar aceptar, se cierra).

8.4 Break Como la sentencia loop es infinita, tenemos que poner algo que lo rompa, si no, el juego los cdigos se estancaran en una operacin que no parara de repetir. Para romper el ciclo, se necesita la sentencia break, metida, para su control, en un condicional. Ej (esto se usa en las escenas, en su main, para que no se cierre la escena hasta que no se cambie la misma (y para refrescar la pantalla)) :: Cdigos :: loop do Graphics.update Input.update update if $scene != self break end end

8.5 While Es una especie de loop do, pero no es infinito. Es decir, el bucle se rompe cuando la condicin puesta tras de s se cumple.

- 17 Vamos a transofrmar el cdigo de antes, en algo ms simple con while:

:: Cdigos :: loop do Graphics.update Input.update update if $scene != self break end end pasa a :: Cdigos :: while $scene == self Graphics.update Input.update update end De todos modos, no lo cambies por lo anterior, que si est as es por algo.

9. Operadores Lgicos: And, Or, Not (and (&&), or (||), not (!))
Imaginemos que en un condicional (o en un While) queremos hacer que funcione slo si se cumplen dos condiciones. Podemos hacer un condicional, y dentro otro o simplemente usar los mtodos and or y not. Estos comandos tambin pueden ser sustituidos por &&, || y ! respectivamente (no confundir ! (not) con != (distinto de)). En el fondo, el funcionamiento de un condicional es el siguiente. Si tenemos la condicin de que cuando x sea igual a un nmero se ejecuten unas determinadas lneas, entonces el ordenador comprueba la condicin. Si x es igual a ese nmero devolver un 1 (true) y si no lo es devolver un 0 (false). Al usar estos operadores lgicos, hacemos al ordenador realizar operaciones lgicas (suma, multiplicacin y negacin). and: se traducira del lenguaje RUBY al lenguaje humano como "y. Es la multiplicacin lgica de los resultados (true o false) de dos valores(vase en Variables > Booleanos). Ej: :: Cdigos :: if x == 12 and y == 54 ... end Tambin vale esto: :: Cdigos :: if x == 12 && y == 54

- 18 ... end He aqu su tabla de la verdad: Tabla de la verdad AND Valor 1 false false true true Valor 2 false true false true Resultado false false false true

or: Se traduce por "o". Corresponde con la suma lgica. Ej: :: Cdigos :: if x == 12 or y == 54 ... end Tambin vale esto: :: Cdigos :: if x == 12 || y == 54 #el smbolo | se escribe con Alt + Cntrl + 1 ... end He aqu su tabla de la verdad: Tabla de la verdad OR Valor 1 false false true true Valor 2 false true false true Resultado false true true true

not: Se traduce por "pero no". No se corresponde con la negacin propiamente dicho, si no por la multiplicacin lgica del primer trmino por la negacin (lo contrario) del segundo. Ej: :: Cdigos :: if x == 12 not y == 54 ... end Tambin vale esto:

- 19 -

:: Cdigos :: if x == 12 y == 54 ... end He aqu su tabla de la verdad: Tabla de la verdad NOT Valor 1 false false true true Valor 2 false true false true Resultado false false true false (slo es vlido cuando el resultado de la 1 condicin es verdadero y el de la segunda falso)

10. Nmeros Aleatorios

Con Ruby, al igual que con casi todos los lenguajes de programacin, se pueden generar nmeros aleatorios. Para ello usamos el comando rand, el cual devuelve un nmero entre el cero y el uno, y por supuesto con decimales, aunque no es necesario cogerlos. De todas maneras, este comando solo probablemente produzca error, ya que necesita un parmetro, que es un nmero por el que se multiplicar este valor aleatorio situado entre el uno y el cero. Este parmetro se incluye entre parntesis detrs del comando, de la siguiente manera: rand (nmero) Es por tanto un comando simple, siempre y cuando se sepa como usarlo. Vamos a usar una pregunta que me hicieron una vez. Imaginemos que queremos obtener un nmero entre el 100 y el 100 -> nmero [-100, 100] (el numero pertenece al intervalo ...). No existe ningn nmero que al ser multiplicado por un nmero entre el cero y el uno nos de o negativo o positivo, por lo que habr que usar otro mtodo. Bien, intentemos ver cuantos valores de nmeros naturales abarca. La variacin de los valores mximos y mnimos de el nmero es 200 (nmero mayor menos nmero menor (100 - (-100) = 100 + 100 = 200)). Ahora tenemos doscientos trminos con el cdigo: rand (200), peor ninguno es menor que cero, es en este momento cuando le restamos 100 al nmero resultado para que nos de un nmero entre el 100 y el menos 100, resultado que estbamos buscando. :: Cdigos :: x = rand (200) - 100

- 20 -

11. Clases (class)

11.1 Introduccin La clase es la unidad de ejecucin por excelencia. Son bloques de cdigo los cuales pueden ser llamados desde otros bloques u desde el juego, con el comando [llamar script].

11.2 Definicin de clases y llamada Para definir una clase como tal, necesitamos dos palabras bsicas mas el nombre de la clase: class y end. Vamos a hacer una clase vaca e intil, sin nada dentro. :: Cdigos :: class clase_de_prueba end No tiene ninguna funcin, no realizar ningn comando, por que no le hemos escrito ningn comando y por que no la hemos llamado. Para llamarla necesitamos una variable vaca el nombre de una clase y el mtodo innato de la clase .new. :: Cdigos :: @clase_llamada = clase_de_prueba.new Tras realizar una llamada, lo mejor es comprobar si el nombre de la clase est bien, y si el mtodo .new est escrito con minsculas. Si se escribe con maysculas, no lo entender. Si estamos llamando a la clase desde el sistema de acciones del RPG Maker, la variable que contenga la clase tiene que ser global (con el smbolo del dlar $)

11.3 Mtodos de clase Si escribimos el cdigo directamente dentro de la clase sin usar mtodos, dicho cdigo ser ejecutado antes de la carga del juego, y solo entonces. Para evitar que se carguen estos procesos antes de tiempo existen las definiciones. Tambin sirven para controlar que procesos queremos que sucedan. La definicin de un Mtodo de clase se realiza con los comandos def y end ms el nombre del mtodo. :: Cdigos :: class clase_de_prueba def cosas end end Ahora se le pueden aadir comandos a ese mtodo.

- 21 Mas tarde podremos llamar a ese mtodo, bien desde otro mtodo dentro de la misma clase (escribiendo el nombre del mtodo), o bien como mtodo de una variable (un punto mas el nombre del mtodo de clase), usada en otra clase.

11.4 Parmetros en los mtodos de clase Un mtodo de clase puede requerir el uso de una variable, la cual necesita ir acompaada de un parmetro para funcionar. Esto se configura en la definicin del mtodo, aadiendo el nombre de una variable entre parntesis. Si queremos emplear ese parmetro despus, solo tenemos que poner su nombre, ya que acta como una variable de mtodo. Se pueden poner todos los parmetros que se quieran. :: Cdigos :: class clase_de_prueba def cosas (parametro) end end Si queremos que un parmetro sea opcional, Entonces tenemos que darle a la variable parmetro que est entre parntesis un valor. El/los parmetro/s que tengan un valor predefinido ha de estar siempre al final. :: Cdigos :: class clase_de_prueba def cosas (parametro= valor inicial) end end Hay una pequea variacin de la creacin de parmetros que nos permite usar esta definicin como si fuera una variable fuera de la clase (dentro sera estpido). :: Cdigos :: class clase_de_prueba def cosas =(parametro) @parametro = parametro #si no ponemos esto el valor #del parmetro se pierde end end Si usis esto ltimo no se puede poner un valor por defecto. De todas formas, existe una forma ms rpida de usar esta, que procedo a explicar en el punto 11.6.

11.5 Superposicin de mtodos de clase Si escribimos dos mtodos de clase con el mismo nombre y el mismo nmero de parmetros (vale con no poner parmetros), se produce una superposicin de mtodos, en la cual, el ltimo mtodo ledo (el que est mas abajo en la pgina de scripts) ser el ejecutado. Pero no sucede esto si el nmero de parmetros es distinto.

- 22 11.6 Formas de acceso a variables de una clase (attr_) Imaginemos que queremos que una variable de una clase sea modificable, o que se pueda leer, o ambas cosas. En tal caso podemos usar mtodos de igual nombre pero distinta funcin: :: Cdigos :: #Primer mtodo (lectura) def cosas return @cosas end #Segundo mtodo (escritura) def cosas =(cosas) @cosas = cosas end El primer mtodo permite la lectura de la variable @parmetro, y el segundo su modificacin (escritura). Ambos son compatibles si se colocan juntos pero no siempre se quiere crear variables de externa lectura y escritura, quizs solo queramos que se pueda leer o quizs que solo se pueda escribir. Para realizar esto se puede usar el mtodo que queramos, o en el caso de que queramos usar ambas, escribiendo dos mtodos similares. Pero existe un sistema mas rpido, las funciones attr. Son tres: attr_reader : cosas permite la lectura de la variable cosas desde otras clases que llamen a esta, aadiendo a la variable que contenga la clase donde se coloca esta funcin un punto y el nombre de la variable, que en este caso es cosas. Ej: algo = @clase1.cosas attr_writer : cosas permite la escritura sobre la variable cosas desde otras clases que llamen a esta, de igual modo que el attr anterior. attr_accessor : cosas permite la escritura y lectura de la variable cosas desde otras clases que llamen a esta. Es la unin de las dos funciones anteriores. Estas tres funciones se escriben (no escribir las tres con la misma variable no vaya a ser que genere error) debajo de la definicin de clase (debajo de la lnea donde pone class ...). Otra caracterstica es que generan una variable de clase llamada igual que la variable que se coloca tras los dos puntos (en este caso es cosas), es decir, que producira con una frmula attr_... : cosas, una variable llamada @cosas.

11.7 Superposicin de clases Si tenemos dos clases del mismo nombre, estas dos se unirn en la memoria del ordenador en una sola clase, en la cual se darn efectos de superposicin de mtodos. Si dos mtodos son iguales, slo se ejecutar el ltimo.

11.8 Alias Si existe la superposicin de clases, y un mtodo de una clase sustituye a otro, cuando queremos que convivan los dos se usa la sentencia alias, la cual se pondra justo antes de la definicin del mtodo que sustituye al otro. Alias funciona as: alias :nombre_del_alias :nombre_original_del_mtodo

- 23 En donde pone nombre_del_alias tendramos que poner un nuevo nick, por as decirlo, al mtodo que es sustituido; y donde pone nombre_original_del_mtodo el nombre original del mtodo, el cual ha de ser distinto del nick (no por que produzca error, si no por que es estpido). Luego se llamara a ese mtodo con el nick, dentro del mtodo que no se ha sustituido. Pongamos un ejemplo: :: Cdigos :: class opciones def opcin_uno (dos) acciones... end end class opciones #aqu va el alias alias :op :opcin_uno def opcin_uno (suerte) aciones de la segunda ... op(suerte) #fjense que hay que introducir los argumentos end end

11.9 Subordinacin de clases Existe un sistema de unin de clases que no implica superposicin de mtodos ni de clases, es mas, las clases no tienen por que tener el mismo nombre. Es la subordinacin, y se representa en la definicin de clase con el smbolo <. Con este sistema se puede usar mtodos de la clase que esta superordinada (la que aparece segunda) en la primera. En el caso de que haya dos mtodos con igual nombre e iguales parmetros, no se realizar superposicin, aunque aparentemente se ejecuta el mtodo de la subordinada (la primera). Existe una forma de llamar al mtodo de la superordinada, que es el comando super(argumentos). Vamos a poner un ejemplo: :: Cdigos :: class ejem def dos(arg=nil) p arg end end class Bar < ejem def dos(arg) super(5) #imprime 5 super(arg) #imprime el valor de arg (7) end end Bar.new.dos 7 Este sistema se usa en las clases-ventana (ver punto ??.?), para poder usar en todas los mismos mtodos, los cuales se sitan en la superordinada Window_Base.

- 24 11.10 Clases-Ventana (Windows) Las clases-ventana son unidades bsicas visuales de una escena (explicada en el siguiente punto). Cuando abrimos el juego, en el Ttulo, el cuadro que nos permite elegir entre las tres opciones que hay, es una clase ventana, En el men, el cuadro que nos permite ver a los personajes del grupo, es una ventana. Son pues estas clases unidades de muestra de informacin. Todas las ventanas que aparecen predefinidas son subordinadas a Window_Base (explicado mas tarde), la cual contiene mtodos que son usados en muchas clases-ventanas. Las ventanas son llamadas por las escenas, y en su conjunto las forman. La clase ventana posee unos mtodos caractersticos, el mas importante es initialize, el cual se ejecuta cuando se usa el mtodo .new. En l se aaden argumentos. No se le debe cambiar el nombre a este mtodo. initialize: es el primer mtodo que se ejecuta cuando se llama a la clase-ventana. En l se ponen los argumentos iniciales. Si mantenemos la subordinacin a Window_Base, cosa que aconsejo ya que de lo contrario deberais estudiar su comportamiento, el primer comando que hemos de incluir es la llamada al mtodo de igual nombre de la clase subordinada. Se usa la sentencia conocida super, tras la cual se especifican la posicin con respecto al eje X (el margen Izquierdo), la posicin con respecto del eje Y (margen superior), el ancho y el alto; separados cada parmetro por comas, en el orden indicado y entre parntesis. :: Cdigos :: super(X, Y, ancho, alto) Tras esto debemos incluir la llamada a contents, lo que nos permitir escribir sobre la ventana. Como es una propiedad de la clase propia, usaremos self.contents, y luego igualamos esta variable o le damos el valor de un objeto Bitmap (B mayscula), seguido por el ancho y el alto (los cuales tienen que ser 32 puntos menores que los mismos parmetros de la ventana), separados por comas y entre parntesis :: Cdigos :: self.contents = Bitmap.new(width - 32, height - 32) Las variables de width y height, que parece que me las saqu de la manga, salen de la llamada anterior al mtodo initialize de la superordinada. Tras esto se definen las propiedades .font.name y .font.size de self.contents, y para ello podemos usar tanto los nombres de las fuentes (entre comillas) y su tamao (nmero), o bien usar las variables globales $fontface y $fontsize, las cuales se pueden modificar en la pgina de cdigos Main. :: Cdigos :: self.contents.font.name = $fontface self.contents.font.size = $fontsize Ahora pongo una lista de comandos con su funcin para la personalizacin de la ventana. Son opcionales: self.windowskin : permite cambiar el skin de la ventana. Para dejar el skin normal, omitir. El skin se llama con la sentencia: RPG::Cache.windowskin(skin), donde en skin se pone el nombre del windowskin que queremos usar.

- 25 self.opacity: permite cambiar la opacidad de la ventana, que no es lo mismo que la opacidad del contenido. Para que el skin no se muestre, a esta propiedad se le da el valor de 0 self.z: profundidad. Si queremos que la ventana est abajo del todo, se le da el valor inferior a 100 y si la queremos sobre el resto de cosas, por encima de 100. Si se omite su valor ser 100, y si se ponen dos ventanas superpuestas, la ltima que fue llamada ser la que est sobre la otra. Por ltimo queda una llamada al mtodo de refresco, que, en el caso de las ventanas, se llama refresh. refresh: en este mtodo se dibujan, por as decirlo, los contenidos de la ventana, ya sean grficos o textos. Como primera medida, se emplea el comando de self.contents.clear, que limpia la ventana de textos e imgenes, dejndola como una ventana nueva y vaca. Tras esto podemos empezar a dibujar los contenidos de la ventana. Los textos se imprimen con la propiedead .draw_text de self.contents. Esta requiere como parmetros X, Y, ancho, alto, texto, alineacin, siendo esta ltima opcional que toma como valor por defecto 0, que significa alineado a la derecha (1 significa a la izquierda y 2 centrado). Si queremos cambiar el color de un texto, antes de imprimir el texto se escribe la sentencia self.contents.font.color, igualada a un color (explicado en el punto 4.6 Puntos y lneas). Los grficos a aplicar en las clases ventana fueron explicados en el punto 4.5. update: slo se usa si el contenido de esa ventana vara con el tiempo, como puede ser un cronmetro. En este mtodo se tiene que hacer una llamada a refresh, y al mtodo update de la clase superordinada (usando super sin ningn argumento).

11.11 Clases-Ventanas de comandos (Selectables) Funcionan casi igual que las ventanas normales, a excepcin de que se subordinan a Window_Selectable, que a su vez est subordinada a Window_Base. Son algo mas complejas que las ventanas normales, ya que incluyen la funcin de eleccin de opciones. Sus mtodos son los mismos que los de las ventanas, pero se aaden algunas cosas: initialize: a todo lo explicado para las ventanas se le une self.index, que indica el ndice donde se situar inicialmente el cursor (0 es el primero y si queremos que no se muestre le damos el valor de -1). En el caso de que el nmero de opciones sea fijo, se le dar el valor a la variable numrica @item_max (no se puede cambiar) del nmero de opciones. Si no es fijo, se le aadir en el refresh. Si tiene mas de una columna, se le tendr que dar el valor numrico de dicha cantidad de columnas a la variable @column_max. refresh: es igual que en las ventanas. Si el nmero de opciones es variable sugiero usar sentencias for. La opcin mas comn para dibujar es llamar a un mtodo, que podemos llamar como queramos, aunque, por guardar similitud con los scripts bsicos, vamos a llamar draw_item (dibuja_item), la cual tendr un argumento, que ser el index que aplicaremos mas tarde a un array (se supone que para hacer esto se necesitan arrays), el cual fue definido en el refresh (puede estar definido manualmente (@array = [opcin 1, opcin 2, opcin 3, ...]), o de alguna otra manera (sugiero que miren los scripts predefinidos para ver otras maneras, aunque son todas con las variables de datos $data_). draw_item: esta clase tiene el argumento index, y sirve para dibujar las opciones (si son pocas o simples no merece la pena). Aqu incluyo la frmula para las x y las y en el caso de que solo haya una columna. :: Cdigos :: x = 4 y = index * 32 Aqu incluyo la frmula para las x y las y en el caso de que haya mas de una columna.

- 26 :: Cdigos :: x = 4 + index % @column_max * ((self.width - 64)/@column_max + 32) y = index / @column_max * 32 Si queremos incluir iconos, al la x del icono se la da el valor de la x antes obtenida, y a la x de se le da el valor de x mas un nmero entre el 26 y el 30 (26 a dos pxeles del icono, 30 a 6 pxeles). update_cursor: solo se usa en el caso de que necesitemos un rectngulo del cursor mas grande o que haga cosas raras. De por si, el rectngulo del cursor tiene 32 de alto, y un ancho especificado en funcin de las columnas y el ancho de la ventana. :: Cdigos :: def update_cursor_rect if @index < 0 self.cursor_rect.empty else #aqu configuramos el cursor self.cursor_rect.set(X, Y, ancho, alto) end end update_help: en el caso de que queramos que use nuestra ventana de comandos una ventana de ayuda, el texto se aadir en este mtodo con la sentencia: @help_window.set_text, la cual solo requiere un texto entre parntesis. Para que esto funcione, es necesario en la clase-escena, explicada mas abajo, crear una ventana que contenga la clase Window_Help, y luego usar esa variable a la que le dimos ese valor y aplicarla a la propiedad .help_window de la clase ventana de comandos.

11.12 Clases-Escena (Scenes) La Escena o clase-escena (Scenes) contiene cdigo que rene otras clases, generalmente ventanas, y las cuales las situa en ella misma. Finalmente, cuando esta clase pasa a ser el valor de la variable global $scene es mostrada en la pantalla del juego, formando as mens, mapas, sistemas de batalla... Estas clases poseen unos mtodos caractersticos. El primero de ellos es el mtodo main el cual ha de ser escrito tal cual, ya que es el principal y el mas importante, a partir de aqu se pueden nombrar el resto de los mtodos como se quieran, aunque aconsejo nombres, los cuales, por ser iguales en todas las escenas predefinidas, ayudar el hecho de que los mantengis. main: es el mtodo principal. Main significa principio, y este nombre se le da al mtodo al cual se acude primero al llamar a la clase escena. En este mtodo se inicia la escena, se configuran los valores iniciales, y se llama a las clases-ventanas. Tras todas las llamadas, se crea el loop, o bucle de recarga, en el cual se llama a el mtodo de recarga de escena, al mismo tiempo que llama al refresco de grficos (Graphics.update (con mayscula la G de Graphics)), y el refresco de los imputs o entradas del teclado (Input.update (con mayscula la I de Input)). En ese mismo loop o bucle se tiene que incluir un sistema de rotura de bucle, por lo que se tiene que incluir dentro del bucle un condicional que se ejecute cuando la variable de escena $scene no sea igual a esa misma clase (se pone self). Por ltimo, justo tras este bucle, se ocultan las clases llamadas con el mtodo .dispose. No se puede aadir argumentos a este mtodo. Olvidaba decir que hay que hacer una llamada al mtodo .transition de Graphics antes del bucle, lo que permitir que los grficos se muevan, es decir, que la pantalla no se quede congelada. Despus del bucle hay que llamar al mtodo .freeze de Graphics,

- 27 para congelar la imagen y que no se vea como van desapareciendo las ventanas una a una. :: Cdigos :: class escena def main # NUNCA PONER ARGUMENTOS #llamada a las clases @clase1 = Clase1.new @clase2 = Clase2.new #Transiccin de grficos (pantalla active) Graphics.transition #loop de refresco loop do Graphics.update #refresco de grficos Input.update #refresco de teclas update #llamada al mtodo de refresco if $scene != self # condicional para usar break break end end #Parada o congelacin de grficos Graphics.freeze #Destruccin de las clases @clase1.dispose @clase2.dispose end # LO QUE SIGUE SE IR EXPLICANDO Vase que los comandos de destruccin de las clases llamadas solo se ejecutarn una vez que se haya roto el bucle. update (mtodo de refresco): Generalmente se le da el nombre de update, aunque le puedes llamar de otra forma, eso si, no te olvides de cambiar el nombre en el main, cuando se llama a este mtodo en el loop de refresco. En esta clase se llama al mtodo update de las clases-ventana llamadas antes, y en el caso de que haya interaccin (generalmente la hay), se usan condicionales con condiciones que llaman a los mtodos de Input (con mayscula la I de Input) .trigger? (pulsacin) o .repeat?(mantener pulsado) seguido de parntesis en cuyo interior se encontrara la Input:: y la tecla correspondiente. Para las teclas aqu les dejo una tabla. Las teclas se pueden modificar pulsando F1 durante la ejecucin del juego. Tecla del juego A B C X Y Z L R Tecla del ordenador Shift, Z Esc, Num 0, X C, Espacio, Enter A S D Q, Re Pg W, Av Pg Uso Cancelar / men Aceptar Anterior Siguiente

Para las teclas de Funcin (F1, F2... F12) se pone su nombre, es decir, una F y su nmero. Ej: F9, F6

- 28 :: Cdigos :: def update # No recomiendo poner argumentos #actualizacin de las clases @clase1.update @clase2.update #comprobacin de teclas Si se pulsa Enter (C) Har algo if Input.trigger? (Input::C) acciones ... end #comprobacin de teclas Si se pulsa ESC (B) Ira al mapa if Input.trigger? (Input::B) $scene = Scene_Map.new end end # AQU SE PUEDEN AADIR MAS COSAS end initialize: este mtodo se ejecuta cuando se usa el mtodo .new de una clase. En este mtodo se aaden los argumentos que no pudiste aadir en el main. Este mtodo se ejecuta antes del main, pero solo si existe. Se suelen poner argumentos opcionales.

12. Clases ms importantes

12.1 Window_Base Aqu se explicarn cada uno de los mtodos utilizables de Window_Base. text_color(n): devuelve un color en base al nmero n que pertenece a un nmero entero del 0 al 7, siendo este el cdigo de colores. 0 1 2 3 4 5 6 7 draw_actor_graphic(actor, x, y): dibuja el grfico de mapa (character) de el personaje alojado en la variable actor, la cual es una variable objeto que contiene $game_party.actors[ ], estando dentro del parntesis un nmero del 0 al 3 entero que corresponder con el ndice del actor. Con la X y la Y, solo decir que la x es respecto a el centro del ancho y la Y con respecto a todo el alto. Segn el dibujo que viene acontinuacin, es el punto donde seala la flecha:

draw_actor_name(actor, x, y): dibuja el nombre del personaje en color blanco. El argumento de actor es el mismo que en el mtodo anterior, y la X y la Y corresponden al la posicin normal. draw_actor_class(actor, x, y): dibuja el nombre de la profesin del personaje seleccionado con actor (mismo sistema de antes) en color blanco. Las coordenadas vuelven a ser normales. draw_actor_level(actor, x, y): dibuja en color azul claro (similar al ndice 1 de text_color (n)) la palabra definida en la Base de Datos para nivel, y en blanco el nivel. Los parmetros son iguales que en los anteriores. make_battler_state_text(battler, width, need_normal): DEVUELVE, no dibuja, entre corchetes el nombre del estado del personale correspondiente con la variable battler, que viene a ser exactamente igual que las variables actor anteriores. En width ir el mximo de ancho del texto, y en need_normal, un valor true o false que indicar si se quiere recibir el texto de [Normal] cuando el personaje no tenga ningn estado alterado.

- 29 draw_actor_state(actor, x, y, width = 120): Este mtodo dibuja el estado del personaje establecido por actor (mismo tipo que en todas). Las coordenadas son normales, y el ancho es opcional, indica lo mismo que el width del mtodo anterior. draw_actor_exp(actor, x, y): dibuja en color azul claro (similar al ndice 1 de text_color (n)) la palabra definida en la Base de Datos para experiencia, y en blanco la experiencia actual, una barra (/) y despus la experiencia para el siguiente nivel. Los parmetros son iguales que en los anteriores. draw_actor_hp(actor, x, y, width = 144): dibuja en color azul claro (similar al ndice 1 de text_color (n)) la palabra definida en la Base de Datos para vida, y en blanco el nivel de vida actual, una barra y el nivel de vida mximo. Los parmetros son iguales que en los anteriores. draw_actor_sp(actor, x, y, width = 144):exactamente igual que antes, pero en vez de dibujar la vida, dibuja la magia. draw_actor_parameter(actor, x, y, type): dibuja en color azul claro la palabra designada en la BD para el parmetro especificado, y luego en blanco su valor. Los argumentos son los mismos que siempre salvo que incluye el parmetro type, que indicar el parmetro a usar: Clave Parmetro 0 Ataque 1 Defensa fsica 2 Defensa mgica 3 Fuerza 4 Suerte / Destreza / Crtico 5 Agilidad / Velocidad 6 Poder Mgico / Inteligencia draw_item_name(item, x, y): dibuja un item, con su grfico. La variable item contiene un objeto $data_items[ ] o $data_weapons[ ] o $data_armors[ ], con su debido nmero entre los corchetes. Las coordenadas no tienen nada raro.

12.3 Scenes En este punto intentar no extenderme mucho, sin explicar algunas clases que, por su falta de calidad, lo mas probable es que sean reemplazadas por otras (me refiero al sistema de batallas). AVISO: nombro a las clases por su nombre real, el nombre de la clase, que generalmente coincide con el nombre de la pgina donde est dicha clase. En el caso del Sistema de Batallas, solo lo mencionar una vez, no cada una de las cuatro pginas en las que est dividida la clase Scene_Title: Clase inicial por defecto. Sus primeros comandos son un condicional que indica si es una prueba de batalla o no, para seguir caminos distintos. En el caso de que no lo sea, empezar cargando los datos del juego (almacenados en la carpeta Data). No carga el archivo scripts, ya que ya fue cargado y compilado, es mas, se estn ejecutando. Tras esto muestra la imagen de title, y, sobre esta la ventana de opciones (Nuevo juego, Cargar juego y Salir), que no es mas que un Window_Comand, que se explicar en el punto 12.4. Tras esto realiza unas pruebas para indicar si debe estar activa la opcin de cargar, y en el caso de que la est, colocar el cursor sobre ella. Luego carga la msica de title, y la reproduce. A partir de all, sigue igual que todas los mtodos main. En el caso de que

12.6 Main (No es una calse) Como primera cosa a decir sobre esta seccin, el Main no es una clase, ya que no es definida como tal. Se inicia, a parte de los reminders que aparecen antes, con la sentencia begin, la cual da inicio a la reproduccin del juego. Todos los cdigos que hayan despus de este bloque begin - end no sern ejecutados, y no se considerarn como existentes.

- 30 Tengamos en cuenta que, cuando se le presenta el archivo de cdigos al juego en ejecucin, este encadena todos los cdigos como si slo fuera una pgina, y todo lo que haya despus de la declarcin antes mencionada, ser excluido de la ejecucin. Por esta razn no se deben colocar las pginas de scripts por debajo de esta pgina. La estructura es simple: :: Cdigos :: begin $fontface = "Lucinda Console" $fontsize = 30 Graphics.freeze $scene = Scene_Title.new while $scene != nil $scene.main end Graphics.transition(20) rescue Errno::ENOENT filename = $!.message.sub ("No se encont el archivo o directorio - ", print("Error RGSS: #{filename}") end

#1

#5

#10 "")

La primera lnea, se inicia el proceso con la sentencia begin. En la segunda y tercera se definen dos variables de mbito global llamadas $fontface y $fontsize, que servirn para determinar la fuente que usar el juego la primera, y el tamao de la fuente, la segunda. Si en una ventana no deseamos que se use los valores definidos por defecto, simplemente tenemos que cambiar la igualacin a la variable global antes mencionada por una igualacin al valor que queremos. Ej: self.contents.font.name = $fontface >>> self.contents.font.name = Fuente deseada En la siguiente lnea, la cuarta, se congela la imagen, es decir, que la imagen se quedar en negro, pausada hasta que se reanude el proceso con la sentencia Graphics.update, la cual se tendr que repetir en un bucle. En la lnea quinta, se dirige la escena principal. En este caso inicia con el title. Si quisiramos que se iniciara con otra escena solo tendramos que cambiar el nombre de la escena, sin olvidarnos de usar el mtodo .new. :: Notas :: Cuidado si queremos que la primera escena sea un mapa (Scene_map) ya que tendremos que incluir, antes de llamar a la escena, una serie de expresiones que se emplean en Scene title que nos activarn la correcta funcionalidad de la clase. Hay un par de cosas modificables: $data_actors = load_data("Data/Actors.rxdata") $data_classes = load_data("Data/Classes.rxdata") $data_skills = load_data("Data/Skills.rxdata") $data_items = load_data("Data/Items.rxdata") $data_weapons = load_data("Data/Weapons.rxdata") $data_armors = load_data("Data/Armors.rxdata") $data_enemies = load_data("Data/Enemies.rxdata") $data_troops = load_data("Data/Troops.rxdata") $data_states = load_data("Data/States.rxdata") $data_animations = load_data("Data/Animations.rxdata") $data_tilesets = load_data("Data/Tilesets.rxdata") $data_common_events = load_data("Data/CommonEvents.rxdata") $data_system = load_data("Data/System.rxdata") $game_system = Game_System.new Graphics.frame_count = 0 $game_temp = Game_Temp.new $game_system = Game_System.new

- 31 $game_switches = Game_Switches.new $game_variables = Game_Variables.new $game_self_switches = Game_SelfSwitches.new $game_screen = Game_Screen.new $game_actors = Game_Actors.new $game_party = Game_Party.new $game_troop = Game_Troop.new $game_map = Game_Map.new $game_player = Game_Player.new $game_party.setup_starting_members #Aqu va el id del mapa al cual transportar el personaje $game_map.setup(38) #Aqu va la posicin inicial sobre el mapa $game_player.moveto(1, 1) $game_player.refresh $game_map.autoplay $game_map.update $active = true $scene = Scene_Map.new En la lnea sexta, sptima y octava, se ejecuta un bucle while, con la condicin de que si el valor de la variable global $scene, la cual contiene la escena en curso, no es nula, es decir, que hay una escena mostrndose, se ejecutar una llamada al mtodo main de la escena. En el caso de que fuera nula y este mtodo fuese llamado, producira un error. La lnea 9 contiene la llamada a la transicin de la escena al negro, que hace que los grficos se degraden en eso de un segundo (20 frames) antes de que se cierre la aplicacin. En las lneas dcima, undcima y duodcima se realiza un rescate de cdigo en el caso de que no exista un archivo o carpeta, permitiendo la bsqueda de dicho archivo o carpeta. La ltima lnea est compuesta por un end que, bsicamente, cerrara la aplicacin. Existe un comando, exit, que nos permitira cerrar la aplicacin en el momento que queramos.