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

Nuestros miembros han publicado un total de 84153 mensajes en 11989 argumentos.

Ejemplos de desliz ("Moviendo cosas")

Ver el tema anterior Ver el tema siguiente Ir abajo

RPG Maker XP Ejemplos de desliz ("Moviendo cosas")

Mensaje por Eron el 2013-03-05, 08:15

Hoy os voy a hablar de algo sobre scripting; ejemplos de desliz para que sepáis como se hacen esas cosas =DnA veces nos interesa que una ventana, una imagen, un texto o lo que sea, que antes estaba en una posición luego pase a otra. Puede que nos interese que pase de una posición a la otra directamente o puede que queramos que haga un desliz.

Tanto el concepto como la ejecución son fáciles.

Empezaré creando una ventana estática que en principio no definiré, porque será una Window_Base vacía. Por ahora no quiero más que eso x'D

Spoiler:
Código:
# EJEMPLO 1 : VENTANA ESTÁTICA

class Scene_Test
  def main
    @test_window = Window_Base.new(100,100,100,100)
    Graphics.transition
    loop do
      Graphics.update
      Input.update
      if $scene != self
        break
      end
    end
    Graphics.freeze
    @test_window.dispose
  end
end

Ahora viene cuando ataca el lobo: queremos que se mueva, por ejemplo, hacia arriba.
Eso lo haremos con un update, y ahí empiezo con la teoría xD

Si queremos que se mueva en un update, le pondremos dentro de ese update que su y augmente. @test_window.y += 10 Así cada vez que se updatee la escena, la ventana subirá esa cantidad.
Cuanto más grande sea ese número, que en este ejemplo será 10, más rápido se moverá hacia arriba por que a cada frame se mueve esa cantidad. Ya sabéis que la velocidad es la distancia entre el tiempo. El tiempo no varía en este caso, es el tiempo de update.

Pero claro, si hacemos esto, se moverá hasta el infinito y nos interesa que al llegar a cierto punto pare.
Es tan fácil como pensáis, ponéis la restricción con un if y ya está.

Spoiler:
Código:
# EJEMPLO 2A : VENTANA EN MOVIMIENTO

class Scene_Test
  def main
    @test_window = Window_Base.new(100,0,100,100)
    Graphics.transition
    loop do
      Graphics.update
      Input.update
      update
      if $scene != self
        break
      end
    end
    Graphics.freeze
    @test_window.dispose
  end
  def update
    if @test_window.y < 100
      @test_window.y += 10
    else
      @test_window.y = 100
    end
  end
end

Puede que os interese definir esa propiedad en el update de la propia ventana y no en el update de la escena. Eso sería bastante lógico para tenerlo más ordenado.
Entonces reescribiendo lo mismo quedaría así.

Spoiler:
Código:
# EJEMPLO 2B : VENTANA EN MOVIMIENTO B

class Window_Test < Window_Base
  def initialize
    super(100,0,100,100)
  end
  def update
    if self.y < 100
      self.y += 10
    else
      self.y = 100
    end
  end
end

class Scene_Test
  def main
    @test_window = Window_Test.new
    Graphics.transition
    loop do
      Graphics.update
      Input.update
      update
      if $scene != self
        break
      end
    end
    Graphics.freeze
    @test_window.dispose
  end
  def update
    @test_window.update
  end
end

Esto no tiene demasiado secreto, mientra lo adaptes dentro del update te servirá.
Hay algo a tener en cuenta, y es que hacer que la velocidad no sea constante sinó que se altere según el tiempo, es tan facil como poner una nueva variable que se altere también en el propio update. Y hacer cambios de velocidad más complejos sería lo mismo con más variables para controlarlo.

Spoiler:
Código:
# EJEMPLO 2C : VENTANA EN MOVIMIENTO C (Velocidad con aceleración)

class Window_Test < Window_Base
  def initialize
    super(100,0,100,32)
    @speed = 1.5
  end
  def update
    if self.y < 480-32
      @speed = @speed**1.05
      self.y += @speed
    else
      self.y = 480-32
      @speed = 4
    end
  end
end

class Scene_Test
  def main
    @test_window = Window_Test.new
    Graphics.transition
    loop do
      Graphics.update
      Input.update
      update
      if $scene != self
        break
      end
    end
    Graphics.freeze
    @test_window.dispose
  end
  def update
    @test_window.update
  end
end

¿Y si no queremos mover la ventana, sinó el texto de su interior?
Bueno, eso gasta más "recursos" pero no es difícil, lo que se suele hacer es definir la escritura del texto en un refresh y en update hacer esa escritura a distintos y de forma similar a la de mover ventana.
Además, solo haremos el refresh cuando haya el movimiento, porque si no el lag sí sería demasiado.
Podemos hacer algo así

Spoiler:
Código:
# EJEMPLO 3 : MOVER EL TEXTO

class Window_Test < Window_Base
  def initialize
    super(50,50,500,500)
    self.contents = Bitmap.new(width - 32, height - 32)
    @cy = 0
    refresh
  end
  def refresh
    self.contents.clear
    self.contents.draw_text(0, @cy, 120, 32, "Hola mundo")
  end
  def update
    if @cy < 100
      @cy += 10
      refresh
    else
      @cy = 100
    end
  end
end

class Scene_Test
  def main
    @test_window = Window_Test.new
    Graphics.transition
    loop do
      Graphics.update
      Input.update
      update
      if $scene != self
        break
      end
    end
    Graphics.freeze
    @test_window.dispose
  end
  def update
    @test_window.update
  end
end

¿Y decís que hasta el momento esto no es demasiado útil? ¡No solo hay desliz de coordenadas! Ejemplos de uso podéis encontrar a patadas =D

Os pongo dos más, no más complicados que los ejemplos anteriores.

Una barra de vida. Como en el caso del texto, pero en vez de cambiar la y cambia la width de la barra según el hp.
Solo va a refresh si hay diferencia entre la hp que marca y la hp real del personaje, siempre para evitar lag.

Spoiler:
Código:
# EJEMPLO 4 : BARRA DE VIDA

class Window_Test < Window_Base
  def initialize
    super(50,50,250,200)
    self.contents = Bitmap.new(width - 32, height - 32)
    actor = $game_party.actors[0]
    @cy = 0
    @meter = RPG::Cache.picture("hp_bar")   
    @cw = @meter.width * actor.hp / actor.maxhp
    @ch = @meter.height
    refresh
  end
  def refresh
    self.contents.clear
    src_rect = Rect.new(0, 0, @cw, @ch)
    self.contents.blt(x, y - @ch, @meter, src_rect)
  end
  def update
    actor = $game_party.actors[0]
    cw_new = @meter.width * actor.hp/actor.maxhp
    if @cw != cw_new
      if (cw_new-@cw).abs < 2
        @cw = cw_new
        refresh
      else
        if @cw < cw_new
          @cw += 2
          refresh
        else
          @cw -= 2
          refresh
        end
      end
    end
  end
end

class Scene_Test
  def main
    @test_window = Window_Test.new
    Graphics.transition
    loop do
      Graphics.update
      Input.update
      update
      if $scene != self
        break
      end
    end
    Graphics.freeze
    @test_window.dispose
  end
  def update
    @test_window.update
    if Input.trigger?(Input::RIGHT)
      $game_party.actors[0].hp += 100
    end
    if Input.trigger?(Input::LEFT)
      $game_party.actors[0].hp -= 100
    end
  end
end

Y por último un marcador de vida numérico, que irá similar a la barra pero no cambiando y ni width ni nada de eso sinó cambiando el número en el draw_text.

Spoiler:
Código:
# EJEMPLO 4B : MARCADOR DE VIDA

class Window_Test < Window_Base
  def initialize
    super(50,50,250,200)
    self.contents = Bitmap.new(width - 32, height - 32)
    actor = $game_party.actors[0]
    @hp = actor.hp
    refresh
  end
  def refresh
    self.contents.clear
    self.contents.draw_text(10,10,100,32,@hp.to_s)
  end
  def update
    actor = $game_party.actors[0]
    hp_new = actor.hp
    if @hp != hp_new
      if (hp_new-@hp).abs < 2
        @hp = hp_new
        refresh
      else
        if @hp < hp_new
          @hp += 3
          refresh
        else
          @hp -= 3
          refresh
        end
      end
    end
  end
end

class Scene_Test
  def main
    @test_window = Window_Test.new
    Graphics.transition
    loop do
      Graphics.update
      Input.update
      update
      if $scene != self
        break
      end
    end
    Graphics.freeze
    @test_window.dispose
  end
  def update
    @test_window.update
    if Input.trigger?(Input::RIGHT)
      $game_party.actors[0].hp += 100
    end
    if Input.trigger?(Input::LEFT)
      $game_party.actors[0].hp -= 100
    end
  end
end

Fin del tutorial
avatar
Eron
Principiante
Principiante

0/3

Créditos 1283

Gracias : 54

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.