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 4193 miembros registrados.
El último usuario registrado es Godot.

Nuestros miembros han publicado un total de 85209 mensajes en 12131 argumentos.

Peseudoclase de RGSS - Orochii #1

Ver el tema anterior Ver el tema siguiente Ir abajo

RPG Maker XP Peseudoclase de RGSS - Orochii #1

Mensaje por orochii el 2017-06-09, 16:45

Algo interesante que tiene Ruby respecto a otros lenguajes de programación/scripting es que absolutamente todo se comporta como un objeto, a diferencia de Java o C++ donde existe una marcada diferencia entre los "tipos primitivos" y las instancias de objeto.

...Pero espera espera espera... ¿Qué es un objeto?

El término objeto es difícil de explicar, pero digamos que es cualquier cosa. Una entidad. Objeto es como se le dice a cualquier elemento en el programa. Un carro, un sprite en pantalla, los datos del jugador... Todo puede ser representado como objetos. Esto luego es tomado para asignarles funcionalidades.

Lo siguiente serían ejemplos de cómo definir varios tipos de objetos. Recordar que en Ruby TODO es un objeto. Un número, una cadena de texto, un valor true/false (positivo/negativo)... ¡incluso la nada es un objeto!
Código:
numeroEntero = 5
numeroReal = 3.5
texto = "Hola mundo"
encendido = true
variable = Carro.new
nada = nil

Para definir un objeto primero se hace una clase. La clase es como una plantilla, qué puede hacer y qué no un objeto que es de esa clase, y los datos o propiedades que le componen.

En el siguiente código hacemos la clase o plantilla de un objeto Carro, y le enseñamos al Carro cómo caminar. En este caso nos mostrará un cuadro de texto con alguna tontería.
Código:
class Carro
  def caminar
    print("El carro se estrelló y todos murieron.")
  end
end

La siguiente es la estructura de una llamada a una instrucción.
Código:
self.visible = true
self es una palabra especial que se refiere al objeto desde el cual se ha llamado el código. Al poner self.visible se refiere entonces al método o valor visible de self, y al igualar a true, cambiará el valor de ésta a true, que por definición, es una instancia de la clase TrueClass
La expresión se puede leer de la siguiente manera: "visible de self es igual a true".

En Ruby, una variable es una entidad que consta de un identificador (nombre de variable), al cual se le asigna una referencia a una instancia u objeto. Esto por medio del "=". Por defecto, TODA VARIABLE, incluso las que no han sido nombradas nunca, empiezan con una referencia a nil, que es un objeto de clase NilClass. El objeto NilClass representa el vacío, es decir, es como que no tiene nada. Pero igual que en el lenguaje español, la nada tiene nombre.

El siguiente código incluye lo que se conoce como un condicional. El bloque de código dentro del condicional se ejecutará sólo si se cumple la condición, es decir, si la expresión da resultado positivo.
s7s8s7s8s787==nil -> pregunta si s7s8s7s8s787 es igual al objeto nil
Puse un nombre al azar xD, y ya que es una variable que en teoría no existía, vale nil por defecto.

Código:
if(s7s8s7s8s787==nil)
  print("casa")
end

En Ruby hay tres tipos de variables, y ese tipo define sólamente en qué contexto es válido su uso, no los contenidos que pueden tener. Ejemplo de esto segundo, una variable miTexto que contiene una cadena de texto puede ser igualada a un número en la siguiente línea, y no habrá problema. En esto hay que tener cuidado y tener siempre claro qué valor tiene cada variable. Es parte de la flexibilidad de Ruby, pero en general puede suponer una mala práctica así que lo mejor es no hacer uso de estas prácticas a menos que se conozca sobre polimorfismo. Cosa que no vamos a hablar acá.
Código:
# para poner comentarios, pones un # al inicio de la línea

mitexto = "hola mundo "
# hacemos algo con el texto como texto
mitexto *= 5 # hola mundo hola mundo hola mundo hola mundo hola mundo

mitexto = 25
# más código random usando a mitexto como número, ejemplo para multiplicarlo
mitexto *= 5 # 125

Para hablar de contextos, primero definamos algunos conceptos.

Un método es como una acción que puede realizar el objeto. De nuevo veamos la clase Carro...
Código:
class Carro
  def caminar
    print("iba a 100 por una calle y chocó")
    explotar
  end
  def explotar
    print("BOOM. ¡Oh no! ¡Mis revistas!")
  end
end

# Este sería el contexto fuera de la clase
carro = Carro.new
carro.caminar

He agregado otro método, llamado explotar. Y como verán, puedo hacer que el carro explote sin poner carro.explotar ni self.explotar, mientras el código esté dentro del contexto correcto. En este caso, estoy dentro de la clase, donde el programa infiere que explotar es equivalente a decir self.explotar, un método que pertenece a la clase desde la que estoy llamando al método.

Fuera de la clase, en cambio, primero debo crear un objeto Carro. Luego decirle a carro que camine. Cuando camine, siempre explotará, porque el ingeniero es un genio y aparentemente hizo un carro bomba que quema revistas.

Entonces, volviendo a contextos, existen las siguientes variables.
Código:
#Variables globales: Las puedes definir y llamar desde donde sea.
#                    Su nombre empieza con $
$mi_variable_global = 5

class Bicicleta
  #Variable de clase: Las puedes llamar desde cualquier lugar en la misma clase.
  #                   Su nombre empieza con @
  @mi_variable_clase = 25
  @otra_variable = 100
  @variable_solo_lectura = 2
  @variable_solo_escritura = 3
  
  def rodar
    # Cuando el nombre de variable no empieza ni con $ ni @, son variables
    # temporales. Existen hasta que su contexto actual termina. En éste ejemplo,
    # el end que corresponde a "def rodar".
    num = @mi_variable_clase * 4
    # Para unir una cadena de texto a un número, debes pasarlo a String.
    # Ésto se hace usando el método to_s (to string, lit. a cadena).
    print("No tiene ruedas, " + num.to_s + " canis.")
  end

  def valor_de_mi_variable
    return @mi_variable_clase
  end

  attr_accessor :otra_variable
  attr_reader :variable_solo_lectura
  attr_writer :variable_solo_escritura
end

# Lo siguiente dará error porque no se puede acceder a variables de clase de esta
# forma. Pero hay varias formas...
bici = Bicicleta.new
bici.mi_variable_clase

# Una forma sería...
numero = 5 * bici.valor_de_mi_variable # 5 * 25 = 125

# Otra forma usando attr_accessor (básicamente crea un método como el que hice
# para @mi_variable_clase de forma automática, usando el mismo nombre).
numero = 5 * bici.otra_variable
# Con attr_accessor sin embargo podemos además asignar valores, cosa que con
# el método que hice no se puede:
bici.otra_variable = 34
# lo siguiente en cambio daría error.
bici.valor_de_mi_variable = 34 # No method error

# En el mismo tema del attr_accessor, tenemos a attr_reader y el poco usado
# attr_writer
a = bici.variable_solo_lectura # Esta se puede leer sin problema
bici.variable_solo_lectura = 5 # Pero intentar cambiarla da error
bici.variable_solo_escritura = 5 #Esta es lo contrario
a = bici.variable_solo_escritura #Leerla dará error, no escribirle

Por ahora lo dejaré hasta aquí. Prueben haciendo estas cosas, metiendo las líneas que puse y experimentando los errores xD. Con esas dudas entonces podría hacer una parte 1.5, y si no hay dudas me plantearé seguir con algo más relacionado a RGSS.

Y claro, cualquier comentario o cosa que sientan que se me haya pasado compartidlo también, que seguro me he liado u olvidado en algo xD. La idea es completar el tema, sea de forma colectiva o con ejercicios que se me ocurran. xD

Salut!

EDIT: Siento si no se entiende bien, pero en caso que necesiten algo más profundizado, en el foro han hecho ya varios manuales básicos más completos. Los dejo como enlaces.

La idea será que en un siguiente post les proponga otras actividades :^DDD (hacer un HUD sencillo, ponerle el mapa al menú como fondo, etc), sólo que quiero que menejen como mínimo los conceptos básicos. Pero igual, si son nuevos en scripting pregunten y asdf y entre todos nos clarificamos xd.
avatar
orochii
Caballero Shiro
Caballero Shiro

0/3

Créditos 6685

Gracias : 337

Volver arriba Ir abajo

RPG Maker XP Re: Peseudoclase de RGSS - Orochii #1

Mensaje por BruMaster7Maker el 2017-06-10, 13:12

Pues me viene como anillo al dedo!!! He estado mirando el de Silvanash que ella me lo pasó, y ahora tu Peseudoclase me va a servir!!!

Contando que soy nulo para esto xD.
avatar
BruMaster7Maker
Reportero

0/3

Créditos 52

Gracias : 16

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.