Mundo Maker
¡Bienvenid@ a Mundo Maker!

¿Quieres aprender todo sobre el RPG Maker?



Regístrate y forma parte de Mundo Maker.
Conectarse

Recuperar mi contraseña

Temas importantes
----------------------------------------
Páginas con recursos RPG Maker
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
----------------------------------------
Afiliados
Estadísticas
Tenemos 4191 miembros registrados.
El último usuario registrado es Victor Inkheart.

Nuestros miembros han publicado un total de 85160 mensajes en 12122 argumentos.

Manejo de scripts

Ver el tema anterior Ver el tema siguiente Ir abajo

Manejo de scripts

Mensaje por youkai el 2013-12-28, 04:25

Nunca habian visto un verdadero tochopost?? Pues he aqui uno de respeto xD
Aqui se va a explicar detalladamente el uso de:

  • Variables
  • Condicionales
  • Bucles
  • Metodos
  • Clases
  • Modulos

Todo viene orientado a Ruby como tal. En este tuto no se habla de nada que sea particularmente de RGSS.

So... Let's begin!

Vocabulario:
Lo pongo primero para que desde ya sepan que es lo que voy a estar hablando.

Bloque de código: Es un conjunto de lineas de códigos agrupadas bajo una misma condición o bajo un mismo llamado.
Bucle: Bloque de código que se repite una X cantidad de veces.
Metodo: Es el bloque de códigos que empieza en def y termina en end.
Compilar: Es el proceso que realiza la maquina para traducir todos los códigos a lenguaje de maquina para de esta forma poder ejecutarlos.
Compilador: El que realiza la compilación. (y de este tema no me pregunten mucho mas que no lo domino bien xP)

clase: Una clase es un bloque de codigos que define objetos mediante metodos y otros bloques de codigos.
objeto: En Ruby casi todo son objetos. Todo lo que se cree mediante una clase se convierte en un objeto. Game_Actor, Scene_Menu, Window_Status, todo eso son objetos.
subclase: Es una clase la cual se deriva de otra adquiriendo los metodos y variables de su superclase o clase padre. La forma de definir una subclase es usando el operador '<', ejemplo:
Código:
   class Yo < Tu
    end
En este caso, la clase Yo sera la subclase de Tu, heredando sus metodos y variables.
Un ejemplo en el maker se ve esto en:
Game_Player, Game_Event que son subclases de Game_Character.

superclase: Es la clase padre de una subclase. Es aquella que va a pasar a sus subclases sus metodos y variables.


Pseudo Variables:
nil: Significa nulo.
self: Se refiere a la propia clase en ejecución.


Estructura del Editor de Scripts y la forma en que funciona:
Como pueden haberse dado cuenta, el editor de scripts esta formado por diversas paginas que contienen bastantes lineas y bloques de códigos. Como quiza piensen, la maquina NO EJECUTA los codigos de arriba hacia abajo, los lee, pero no los ejecuta; de hecho, se empieza desde Main. Los codigos se leen en un orden logico y ordenado. Si se fijan, en Main encontraran una linea que dice:
$scene = Scene_Title.new
Eso significa que empieza a ejecutar desde Scene_Title. Si quieren ver que es lo que llamara después, lean en Scene_Title.

Dentro de un bloque de codigos es que se leen de arriba a abajo.


Variables de Ruby:
El procedimiento de asignacion de valores a las variables se hace de la siguiente forma:
Código:
variable = valor
Las variables SOLO PUEDEN GUARDAR UN VALOR.
Ruby tiene diversos tipos de variables: globales, de instancia, locales y globales.

Globales: Toda variable que empiece con el simbolo de dinero($) se considera una variable global. A todas las variables globales se puede acceder desde cualquier parte del programa para leerlas o modificarlas.
Ejemplo de variables globales:
Código:
   $scene    $game_variables    $DEBUG      $YouKaI
No importa como quieran escribirlas, siempre que empiecen con $, son variables globales.

De Instancia: Toda variable que empiece con una arroba(@) es considerada una variable de instancia. A este tipo de variable solo se pueden acceder desde cualquier metodo de su clase o subclase.
Ejemplo:
Código:
   @actor  @You_Kai    @_lol
Al igual que las globales, como quiera que las escribas, mientras empiecen con @, seran variables de instancia.

A todas estas variables explicadas anteriormente si se les intenta llamar sin haberles asignado un valor, tomaran automáticamente como valor nil.

Constantes: Las variables que comiencen con la letra inicial mayuscula son consideradas variables constantes. Su valor no se le puede modificar una vez asignado, si intentas modificarles su valor desde otra parte del programa, resultara en un error. Si se intenta llamar a una constante indefinida tambien resultara en un error.
En toda clase o metodo en que se defina una constante, se les puede llamar desde una subclase, clase que incluya el metodo en que fue creada o desde el mismo metodo. Para llamar una constante de fuera de su clase o metodo, se usa el operador '::' (sin comillas)
Código:
    GLOBAL    Global    YouKai
Ejemplo de uso:
Código:
   class Youkai
    Me = 5
    end

    class Tu < Youkai
    p Me  # => 5
    end

    p Youkai::Me  # => 5

Locales: (Este tipo de variable es un poco pesada de explicar...xD pueden ser confusas)
El problema con las variables locales es que coinciden con las llamadas de metodos. Por ejemplo, en las Windows index es el metodo que determina la posicion del cursor, pero si hacemos esto:
Código:
   index = 3
Ese codigo dejara de llamar al metodo y pasara a ser una variable local de valor 3. Entienden? xD No se preocupen, cuando pasen ese tipo de cosas, lo que se usa para llamar el metodo es:
Código:
   self.index
Ya que si agregamos a self entonces buscara obligatoriamente un metodo contenido en la clase que trabajamos o superclase de la que estamos trabajando.

Entonces, volviendo al tema. Las variables locales y llamadas a metodos empiezan con letra minuscula o '_'. Intentar llamar a una variable local indefinida resultara en una llamada a metodo.


Metodos:
Los metodos, como explique anteriormente, son aquellos bloques de codigo que empiezan en def y terminan en end.
Código:
   def initialize
    @foo = 5
    if @foo == 5
    @foo
    end
    for e in 0..@foo
    @foo = @foo + e
    end
    end
Dentro de un metodo es donde se desarrolla la mayor parte de un script. Se crean y se llaman variables. En su interior se realizan calculos, modificaciones a otras variables o lo que quieras hacer. Siempre que son llamados devuelven un valor, el cual puede ser el de la ultima variable escrita en el metodo o el ultimo valor devuelto por cualquier otro metodo llamado desde su interior.
Tambien ellos pueden pedir argumentos para funcionar. En este caso serian de esta manera:
Código:
   def mov(x, y)
    if x == 5 and y == 3
    move_actor_alinfinito
    end
    end
    def algo
    mov(5, 3)
    end
Como ven, este metodo te pide que le des un valor para las variables locales x ý y. Si no le pasas valores o argumentos para esas variables resultara en un error. En el ejemplo anterior pueden observar diversas cosas de las que habia hablado, tales como el llamar a otro metodo dentro de un metodo(move_actor_alinfinito) y la forma de pasarle los argumentos a un metodo que los pida. Es importante respetar el orden, en este caso al pasar los argumentos quedo de esta forma: x = 5, y = 3
Pero si hubiesemos pasado los argumentos al reves hubiese sido: x = 3, y = 5
Si hubiesemos pasado un argumento de mas daria error, al igual que si hubiesemos dejado uno.


Errores clásicos en los scripts:

SyntaxError: Ocurre tras un error de sintaxis en la programacion. Un end que falte, un parentesis extra o cualquier cosa que sea de agrupamiento de datos que no este cerrado.
ArgumenError: Ocurre al intentar pasarle a un metodo un numero incorrecto de argumentos.
NameError: Ocurre al intentar llamar a una variable local o constante indefinida.
NoMethodError: Ocurre al llamar un metodo inexistente.
ZeroDivisionError: Ocurre al intentar realizar una division por 0.


Bloques de Códigos:
Como expliqué en el encuentro anterior un bloque de códigos es una secuencia de lineas de código agrupadas bajo un mismo parámetro o condición. Casi todos los comandos de programación dan lugar a bloques de códigos, pero de todas formas voy a presentar lo que pienso explicar en esta ocasión.
Código:
   if    for    while    def
    class    module    unless    case
Estos comandos están divididos en diferentes clasificaciones, las cuales son:
NOTA:
En todas las sintaxis, lo que este encerrado entre corchetes ([]) significa que no es de uso obligatorio

Principales operadores de Ruby:
Código:
   >    Mayor que
    >=  Mayor o igual que
    <    Menor que
    <=  Menor o igual que
    ==  Igual que
    === Identico a
    !=  Distinto que
Estos son los operadores mas básicos usados generalmente en condicionales. Por supuesto que hay muchísimos mas pero no los voy a explicar puesto que requieren un nivel mayor de conocimiento y dominio del lenguaje.

Operadores matemáticos:
Código:
   +    Mas
    -    Menos
    *    Multiplicación
    /    División
    %    Resto
    **  Potencia

Pues estos son los matemáticos xD Su uso no creo que sea necesario explicarlo mucho xD
Código:
   var = 5 + 9  #=> 14
    var = 5 - 9  #=> -4
    var = 5 * 9  #=> 45
    var = 45 / 9  #=> 5
    var = 9 % 5  #=> 4 (es el resto de dividir 9 / 5)
    var = 5 ** 2  #=> 25


Condicionales:
Código:
   if  unless    case
Estos comandos lo que hacen es evaluar los códigos que pongas como condiciones. Si el resultado de esta evaluación es true, el bloque se ejecuta; si es false, el bloque queda omitido y el programa continua compilando.

Condicional if:
Ejemplo:
Código:
   ex = 5
    if ex == 5  # Como ex es igual a 5, se cumple
    p "Es 5"
    elsif ex > 5
    p "Es mayor que 5"
    else
    p "Es menor que 5"
    end
Sintaxis:
Código:
if expr [then]
expr ...
[elsif expr [then]
expr ... ]
...
[else
expr ... ]
end
Siempre que la condición sea verdadera ejecutara el bloque de códigos que le sigue a la condicional. En caso de ser falsa, evaluará la condición escrita en elsif. Se pueden especificar varios elsif. En caso de que no se cumpla ninguna de las condiciones escritas, se evaluará el bloque correspondiente a else, en caso de que haya alguno.
Debo de decirles que no es obligado que existan bloques elsif o else. Uno los agrega a conveniencia y cuando no exista ninguno de ellos y no se cumpla la condición simplemente pasara del if y continuara compilando.


Condicional unless:
Código:
   ex = true
    unless ex  # Esto es lo mismo que decir: ex == true
    p "Es falso"
    else
    p "Es verdadero"
    end
Sintaxis:
Código:
   unless expr [then]
      expr ...
    [else
      expr ... ]
    end
Este bloque funciona casi exactamente igual a if, la diferencia está en que es lo contrario. Me explico: como había dicho, en if cuando la condición es verdadera se evalúa el bloque correspondiente al if; de lo contrario se recurre a elsif o else en caso de que existan.
En el caso de unless, se evaluara su bloque solo cuando la condición NO SE CUMPLA, o sea, que sea falsa. También debo aclarar que en este bloque NO SE PUEDEN ESPECIFICAR elsif, solo admite a else.
LOS VALORES nil Y false SON CONSIDERADOS FALSOS, ¡TOOOOOODOOOOSSS! LOS DEMÁS SON CONSIDERADOS VERDADEROS


Condicional case:
Código:
   ex = 5
    case ex
    when 0, 1, 2, 3, 4
    p "Es 0, 1, 2, 3 o 4"
    when 5
    p "Es 5"
    when 6..20
    p "Está entre 6 y 20"
    end
Sintaxis:
Código:
   case expr
    [when expr [, expr] ... [then]
      expr ..]..
    [else
      expr ..]
    end
Esta condicional es un poco mas pesada de explicar...asi que perdonen si entienden poco/nada xD
En este caso se crea un bloque de códigos que funciona como condicional para UNA SOLA expresión(la que se especifica en case) Los valores con los cuales se va a comparar se especifica mediante los when. Cuando uno la condición se cumpla en uno de los when, se ejecutara el bloque correspondiente a ese when. En esta condicional también se puede especificar else, el cual correrá si no se cumple ningún when.
En pocas palabras, case funciona parecido a: (este ejemplo no tiene que ver con el case del ejemplo inicial, se parece pero no es lo mismo)
Código:
   if ex == 5
    ....
    elsif ex == 6 or ex == 8
    ....
    elsif ex == 7
    ....
    end


Bucles:
Código:
   for    while
Un bucle, en español, es algo(xD) que se repite una y otra vez como mismo los carros compiten en un circuito cierta cantidad de vueltas girando en el mismo sentido y en la misma pista.
En programación un bucle no difiere mucho de esto. Se le llama bucle a aquellos comandos que lo que provocan es la evaluación de un o unos determinados bloques de códigos X cantidad de veces.
También debo decirles que los bucles son mucho mas complejos que las condicionales y, por tanto, un poco mas pesados de explicar en un lenguaje que todos puedan entender ^^


for
Código:
   for var in 0..6
    p var
    end
Sintaxis:
Código:
   for localvariable ...  in expr [do]
      expr ..
    end
Este comando lo que provoca es la evaluación del definido en su interior la cantidad de veces especificada en la expresión expr La variable que especifiques como localvariable sera la encargada de ser el indice del for, o sea, tomara el valor por el cual vaya el for. Para una mejor comprensión pueden poner el ejemplo dentro de un evento en el maker y correr ese evento,; ahí verán lo que les quiero decir.

Como el Ace es un poco estúpido(o lo hicieron estúpido) y antiRuby, tienen que usar este ejemplo para que les funcione:
Código:
       for var in 0..6
        msgbox var
        end
   Repito, esto es solo en el caso del Ace...hay que cambiar p por msgbox...En el resto de los makers eso no tiene problema.


while

Ejemplo:
Código:
   i = 0
    while i < 6
    p i
    i += 1
    end
Sintaxis:
Código:
   while expr [do]
      ...
    end
En el caso de while, el bloque de códigos se ejecutara una y otra vez mientras que la condición especificada permanezca como verdadera.



Clases y Métodos:

Clases: class

Ejemplo:
Código:
class Foo < Super
def test
:
end
:
end
Sintaxis:
Código:
class identificador ['<' superclase ]
expr ..
end
Ruby es un verdadero lenguaje Orientado a Objetos en donde todo lo creado representa un nuevo objeto. Crear una clase no es mas que dar los planos de un nuevo objeto. Al igual que un ingeniero diseña los planos de un carro o un edificio con todos sus detalles; nosotros diseñamos una clase con todas las características, accesorios y eventos que realizara ese objeto. Debo repetir que una clase NO ES UN OBJETO, solo son "planos" del objeto que se creara después.

Hablando ahora de clases:
Este comando es el encargado de crear una clase. El nombre de la misma no es mas que un identificador que empiezan con letra inicial mayúscula. La creación de una clase le asigna esa clase a una constante especificada en un identificador.

Un identificador es una secuencia de caracteres que comiencen con una linea baja(_) o cualquier otro caracter alfabético y consiste en una secuencia de lineas bajas u otros caracteres alfanuméricos(letras y números). No tiene límite de longitud.
   Ejemplo:
Código:
        variable    Constante  Scene_Title    cualquier_otra_COSA
Cuando una clase ya está definida y creamos otra definición de clases con el mismo nombre que la antes creada, se le agregaran los métodos y otras definiciones de la clase nueva a la anterior.
Ejemplo:
Código:
   class Foo < Array
      def foo
      end
    end

    class Foo
      def bar
      end
    end
   Resultado:
Código:
   class Foo < Array
      def foo
      end
      def bar
      end
    end
Dentro de una clase, self se refiere a la clase en sí misma. Las clases pueden contener bloques de códigos que se ejecutaran arbitrariamente una vez que la clase es definida, o sea, sera lo primero en ejecutar cuando se cree el objeto correspondiente a esa clase o sea definida.


Módulos: module
Ejemplo:
Código:
   module Foo
      def test
        :
      end
        :
    end
Sintaxis:
Código:
   module identifier
      expr ..
    end
Los módulos funcionan casi igual a las clases. El modulo se le asigna a un identificador cuyo nombre será el nombre del modulo. Cuando un módulo se define un modulo con el mismo nombre a uno ya existente, se le agregan al anterior los métodos y otras definiciones del nuevo metodo al anterior.

Y AHORA AL PLATO FUERTE:

Métodos: def
Ejemplo:
Código:
   def fact(n)
      if n == 1 then
        p 1
      else
        p n * fact(n-1)
      end
    end
Sintaxis:
Código:
   def method_name ['(' [arg ['=' default]] ... [',' '*' arg] ')']
      expr ..
    [rescue [error_type,..] [then]
      expr ..]..
    [ensure
      expr ..]
    end
La sintaxis de los métodos no quise cambiarla para que vean hasta que punto de complejidad pueden llegar. Seguro que les resultara raro cosas como rescue y ensure puesto que en el maker casi nunca se usan. Esos comandos solo se ven en scripts que modifiquen avanzadamente métodos y clases internas de Ruby o RGSS o que trabajen con archivos.
Bueno, está es la sintaxis para definir métodos. En otras palabras, define un método correspondiente a la clase o modulo en que fue creado. Los métodos, en su forma sencilla de creación, pueden ser llamados desde cualquier parte de su clase. Para hacerles llamados desde lugares externos a la clase en la cual han sido definidos, es necesario primero crear el objeto correspondiente a la clase y luego hacerles el llamado usando la sintaxis:
Código:
   class Test
    def arg
    p 600
    end
    end

    class Other
    def num
    test = Test.new  # Aquí hemos creado el objeto y almacenado en la variable local test
    test.arg  # Aquí llamamos el método arg correspondiente al objeto
              # almacenado en la variable test
    end
    end
Los métodos pueden tener distintos tipos de llamados. El citado en el ejemplo anterior es básico: llamado sin argumentos. Estos tipos de llamados son:
- Sin argumentos.
- Con argumentos.
- Con argumentos predefinidos.
- Aceptando todos los argumentos que le pases.

Sin argumentos:
Ejemplo:
Código:
   def foo
    ....
    end
    def foo()
    ....
    end
Este tipo de método es el que se llama sin necesidad de pasarle ningún valor o argumento. El corre todos los bloques contenidos en su interior y finalmente devuelve el valor de la ultima linea de códigos evaluada o la especificada con return(esto lo explico al final)

Con argumentos:
Código:
   def foo(arg, arg2)
    p arg, arg2
    end

    foo(5, "Hola")  #=> 5, "Hola"
Básicamente hace lo mismo que el caso anterior, evalúa todas sus lineas y devuelve el ultimo valor. La diferencia esta en que este método para correr necesita que le envíen argumentos. Los argumentos que le envíes se convierten en variables locales de ese método. Este tipo de método es usado para que no exista la necesidad de repetir cálculos por todo el script; se calcula una vez y ese resultado se le pasa como argumento a un método para que realice cierta tarea que solo puede hacer con ese resultado. Un ejemplo de esto en el maker lo podemos ver en TODAS las Windows.

Con argumentos predefinidos:
Ejemplo:
Código:
   def foo(arg = 5, arg1 = "Hola")
    p arg, arg1
    end
    foo    #=> 5, "Hola"
    foo("NOO")  #=> "NOO", "Hola"
    foo(99, 66)  # => 99, 66
Es lo mismo que el anterior, lo único que en este caso no seria obligado pasarle argumentos a ese método. En caso de que no reciba argumento alguno o solo reciba 1 de los 2 argumentos que pide, ellos tomaran ese valor que le has predefinido. Recuerden que los argumentos se toman por orden, o sea, no es posible cambiar el 2 argumento predefinido sin tocar el 1. Si solo pones valor para 1 argumento predefinido este valor sera tomado por el primer argumento predefinido.

Aceptando todos los argumentos que le pases:
Ejemplo:
Código:
   def foo(*arg)
    p arg
    end

    foo(1,14,56,235,2,5,25,25,124)  #=> [1,14,56,235,2,5,25,25,124]
    foo("", "Aquí", 8, [6])  #=> ["", "Aquí", 8, [6]]
    foo()  #=> []  NOTA: decir foo() es lo mismo que foo
Como ven, esto acepta todos los argumentos que le pasemos y los agrupa a todos en un Array(en una próxima ocasión explico los Arrays). Para crear un argumento de este tipo simplemente tenemos que agregar un asterisco(*) antes del nombre del identificador del argumento.

Con todos los tipos de argumentos:
Código:
   def foo(arg, arg1 = 69, *resto)
    ...
    end
¿Quién creía que no podíamos mezclarlos todos? Claro que podemos, lo que tenemos que seguir un orden para eso. Ese orden es el que podemos ver en el ejemplo.
- Primero los argumentos que arbitrariamente requieren que le pasemos un valor
- Luego los argumentos predefinidos, aquellos que le pasamos valores si queremos(xD)
- Finalmente, el argumento que recoge todo lo demás y lo agrupa en un Array
Lógicamente es imposible organizarlos de otra manera.


Errores clásicos del tema:
Código:
   NameError
    Undefined local variable or method 'nombre del identificador' for
    #Objeto
Ocurre cuando intentamos llamar a un método que no existe dentro de una clase.
Código:
   ArgumentError
    wrong number of arguments([numero pasado] for [numero que acepta])
Este otro clásico es cuando intentamos pasar a un método una cantidad mayor de argumentos de la que el acepta. Recuerden que si incluye un argumento tipo * este error no sucederá puesto que acepta todo lo que le pasemos, en cambio pudiera funcional mal el script.
Código:
   NoMethodError
    Undefined method 'nombre del identificador' for #Objeto
Este error solo se da cuando es evidente que lo que intentamos llamar fue un método. Por ejemplo si hacemos algo como esto:
Código:
   ex()
Es evidente que estamos llamando un método ya que ninguna variable local acepta esa sintaxis. Esta es otra forma de llamar un método que posea el mismo nombre que una variable local Y NO PIDA ARGUMENTOS dentro de un mismo método, usando los paréntesis. Si pidiera argumentos no es necesario ya que obligado tienes que poner paréntesis para pasarle los argumentos xD

Y finalmente el ansiado final. Creo que todo el que haya leido el post completo merece una medalla y algunas monedas XD (pero pidanselas a danga...a mi no XDDD)
En dependencia del exito que logre este post pensare la posibilidad de continuar enriqueciendolo hablando sobre las clases y modulos de Ruby y RGSS y el proximo lanzamiento de este tuto vendria en forma de libro xD
Saludos,
¥oukai
avatar
youkai
Soñador
Soñador

0/3

Créditos 280

Gracias : 10

Volver arriba Ir abajo

Re: Manejo de scripts

Mensaje por orochii el 2013-12-28, 05:06

So... Let's begin!
Tenías que poner nada más begin e indentar el resto del post. xDDDDDDD...

Pues bueno, está bastante trabajadox el psot... pots... post! =D. Quiero agregar una cosa nada más, el orden importa, pero sólo en caso que se usen módulos. Los módulos no se instancian, por lo que uno usa sus métodos directamente desde la misma clase, como una superinstancia (?). Y si una clase hace una referencia a un módulo que, en el orden lógico arriba-abajo, no ha sido definido, te tira error, un NameError si no me falla la memoria xd.

Pero en fin, sean ordenados al scriptear y eso no les pasará nunca :P.

¡Buen material!
avatar
orochii
Caballero Shiro
Caballero Shiro

0/3

Créditos 6680

Gracias : 337

Volver arriba Ir abajo

Re: Manejo de scripts

Mensaje por youkai el 2013-12-28, 07:00

Orochii en realidad no es asi como dices, y me explico segun como creo que sea XD:
Cuando lanzamos el proyecto(sea para probarlo o no) se crean todas las constantes que haran referencia a clases o modulos por lo que el orden no importa mucho A MENOS QUE tengamos comandos o bloques de codigo que esten dentro de una clase/modulo pero no dentro de un metodo. Algo como esto:
Código:
class Asd
  p cosa_random
  def initialize
    .....
  end
end
En este caso ese "p cosa_random" se va a ejecutar como primera cosa en el juego, se haga o no referencia a la clase que lo contiene, y mas nunca se volvera a correr(a menos que reiniciemos el juego xD). Ese viene siendo el caso de los "attr_...".
Y sobre lo que hablaba del orden: si hacemos algo como esto y dentro de los codigos que hayamos escrito esta la referencia a un modulo, entonces si es obligatorio poner el modulo antes que la clase. De lo contrario el orden no importa mucho :P
Un ejemplo clasico de esto, que es a lo que se refiere orochii, es usar el include con un modulo aun no definido en el momento que se leyo la clase.
De todas formas, por un problema de estetica siempre queda mas bonito poner los modulos arriba y debajo las clases XD

Para sintetizar mi idea: todos los codigos que no esten incluidos dentro de un metodo seran ejecutados durante la compilacion del juego. x'D
Saludos,
¥oukai
avatar
youkai
Soñador
Soñador

0/3

Créditos 280

Gracias : 10

Volver arriba Ir abajo

Re: Manejo de scripts

Mensaje por Wecoc el 2013-12-28, 16:56

Youkai, éste es el mejor tocho-post que he visto en mucho tiempo xD Reconozco que hasta he aprendido cosas nuevas con él y refresqué cosas que tenía medio olvidadas.

Para gente que ya sepa de todo ésto quiero hacer una recomendación un tanto rara xD Leerse los scripts de LiTTleDRAgo por encima, a modo de aprendizaje. Yo lo hice alguna vez y aprendí a hacer cosas que ni se me habrían ocurrido, especialmente en los que son compatibles con todos los maker a la vez. Personalmente aprendí parte de lo que sé de scripts gracias a los clásicos de MOGhunter entre otros... yo estoy hablando de un nivel digamos un poco mayor xD

Nota: Puede que algún día recopile algo así como "The best of LiTTleDRAgo", hablando de éste tema.
avatar
Wecoc
Administrador
Administrador



Créditos 9264

Gracias : 502

Volver arriba Ir abajo

Re: Manejo de scripts

Mensaje por Metalero el 2013-12-28, 21:43

Muy buen tuto, lograste abarcar todo lo basico (y no tan basico) si irte por las ramas (como me ha pasado a mi con mis tutos XD)

Voy a aportar 2 cosas al tema

1)

self: Se refiere a la propia clase en ejecución.

Aca seria mejor decir que self se refiere al objeto o instancia de esa clase, que se esta "evaluando" en ese momento.
Tecnicismos para que entienda mejor.

2)

Ruby tiene diversos tipos de variables: globales, de instancia, locales y globales.

Tambien existen las variables de clase, que son aquellas que empiezan con "doble arroba":

@@variable_de_clase

estas variables se declaran en el cuerpo de la clase generalmente (no recuerdo bien, pero supongo que se pueden declarar tambien dentro de metodos)

y son "la misma variable" para todas las instancias de una misma clase.
Desde afuera se usan con 

MiClase.variable_de_clase = ...

http://www.railstips.org/blog/archives/2006/11/18/class-and-instance-variables-in-ruby/

A ver como sigue el tuto. 
Algo que estaria bueno hacer (yo creo que lo habia posteado hace mil años, para RMXP, pero ya ni me acuerdo) es dar una descripcion de la "arquitectura" del maker

Orden de ejecucion de escenas, estructura de menues con Windows, clases "globales" como Temp o System, etc.


Última edición por Metalero el 2013-12-29, 02:39, editado 1 vez

_________________
avatar
Metalero
Administrador
Administrador



Créditos 1716

Gracias : 99

Volver arriba Ir abajo

Re: Manejo de scripts

Mensaje por youkai el 2013-12-28, 23:21

Muchas gracias por la asistencia Metalero XD
Sobre una mejor explicacion de self pues...yo no pudiera haberlo dicho asi XD Para la parte teorica soy bastante malo...de por si me costo bastante lograr explicar todo este tuto en un lenguaje comprensible para todos :(
Y sobre las variables de clases no hable ya que tampoco queria entrar en temas mas complejos y mucho menos vistos en el maker como tal...y para que engañarnos: tampoco conocia tanto del tema como para poder decir algo con seguridad al respecto XD
Y para proximas expansiones(?) del tuto eso es lo que pienso hacer. Quiero explicar toda la arquitectura del maker pero eso si que me va a tomar tiempo...es bastante contenido del que hablar XD

En fin, por ahora no pienso seguir con esto pero para año nuevo me pienso meter mas en el tema :)
Saludos,
¥oukai
avatar
youkai
Soñador
Soñador

0/3

Créditos 280

Gracias : 10

Volver arriba Ir abajo

Re: Manejo de scripts

Mensaje por Contenido patrocinado


Contenido patrocinado


Volver arriba Ir abajo

Ver el tema anterior Ver el tema siguiente Volver arriba


Permisos de este foro:
No puedes responder a temas en este foro.