~Base De Datos de Script de EMD~

Estado
Cerrado para nuevas respuestas
Mensajes
9.007
Reacciones
224
Puntos
0
Ubicación
00 Qan[T]
-Nombre Del Script:Phone System
-Version Del Script:0.1B
-Rpg Maker:VX

-Introducion:
Es un sistema de telefonía móvil, que esta en su primera beta, por lo tanto tiene mucho que mejorar y se pueden encontrar bugs.
Con él tienes un telefono movil, con el cual puedes recibir sms de los NPC.

-Demo:
http://www.mediafire.com/download.php?zwzkuetixvv

-ScreenShot:
my.php

my.php

my.php

my.php

my.php

-Script:
no disponible
-Creditos:
Necrozard
 
Mensajes
9.007
Reacciones
224
Puntos
0
Ubicación
00 Qan[T]
-Nombre Del Script:Tetris
-Version Del Script:no hay informacion
-Rpg Maker:XP

-Introducion:
Este script no necesita de ningun grafico adicional solamente lo pegan arriba del main y listo..
Esta en frances la explicacion pero lo q se ve en el juego en español (traducido by Yo: Dubriel)
como bien dice la explicacion para empezar el juego usar el comando(en llamar script): Tetris.start
Con la barra espaciadora se rotan las figuras

-ScreenShot:
dibujonv2.png


-Script:

Código:
#-------------------------------------------------------------------------------------------------------------------------------
#Dans un evenement, faire "inserer un script" et taper :
#Pour lancer le jeu
#Tetris.start(niveau)
#remplacer niveau par le niveau auquel le jeu commence (1 par défaut)
#-------------------------------------------------------------------------------------------------------------------------------
#Pour recuperer le score dans une variable :
#Tetris.score_to_var(num)
#En replaçant num par le numéro de la variable
#De même pour récuperer le nombre de ligne détruite ou le niveau atteint :
#Tetris.ligne_to_var(num)
#ou
#Tetris.niveau_to_var(num)
#=======================================================================

module Tetris
#Le fond d'écran : remplacer nil par le nom du fichier sans l'extension ( doit se trouver dans le dossier Pictures).
FOND_ECRAN = nil
#Changer les deux premieres coordonnés pour déplacer les différents éléments du jeu
  ECRAN_JEU = Viewport.new(52, 0, 210, 462)
  ECRAN_PIECE = Rect.new(400, 80, 116, 116)
  ECRAN_SCORE = Rect.new(360, 220, 200, 122)
  
  
#======================================================================
#Définitions des différentes pieces avec leurs couleurs
#======================================================================
  
  PIECES = [[[[false, false, false, false],
                        [false, true, true, false],
                        [false, true, true, false],
                        [false, false, false, false]],
                        Color.new(0, 0, 255)],
                      [[[false, true, false, false],
                        [false, true,false, false],
                        [false, true, false, false],
                        [false, true, false, false]],
                        Color.new(255, 0, 0)],
                      [[[false, false, false, false],
                        [false, true, false, false],
                        [true, true, true, false],
                        [false, false, false, false]],
                        Color.new(255, 85, 0)],
                      [[[false, false, false, false],
                        [false, true,true, false],
                        [true, true, false, false],
                        [false, false, false, false]],
                        Color.new(0, 255, 0)],
                      [[[false, false, false, false],
                        [false, true,true, false],
                        [false, false, true, true],
                        [false, false, false, false]],
                        Color.new(255, 0, 255)],
                      [[[false, false, false, false],
                        [false, false,true, false],
                        [true, true, true, false],
                        [false, false, false, false]],
                        Color.new(255, 255, 0)],
                      [[[false, false, false, false],
                        [true, false,false, false],
                        [true, true, true, false],
                        [false, false, false, false]],
                        Color.new(119, 85, 136)]]
  
#=======================================================================
#Demarre le jeu
#=======================================================================
  def Tetris.start(n = 1)
    @score = 0
    @ligne = 0
    @niveau = 0
    $scene = Scene_Jeu.new(n)
  end
  
#=======================================================================
#Score, nombre de lignes détruites et niveau
#=======================================================================
  def Tetris.score(s = 0)
    @score += s
    return @score
  end
  
  def Tetris.score_to_var(n)
    $game_variables[n] = @score
  end
  
  def Tetris.ligne(l = 0)
    @ligne += l
    return @ligne
  end
  
  def Tetris.ligne_to_var(n)
    $game_variables[n] = @ligne
  end
  
  def Tetris.niveau(n = 0)
    @niveau += n
  return @niveau
  
  def Tetris.niveau_to_var(n)
    $game_variables[n] = @niveau
  end
    
  end
  
  
#=======================================================================
#PIECE
#=======================================================================
  class Piece < Sprite
  attr_reader :matrice
    def initialize
      super(ECRAN_JEU)
      @piece = PIECES[rand(7)]
      @matrice = @piece[0]
      self.bitmap = Bitmap.new(84, 84)
      @couleur = @piece[1]
      self.y = 0
      self.x = 42
      @undo = proc {self.visible = false}
      refresh
    end
    
    def refresh
      self.bitmap.clear
      4.times do |i|
        4.times do |j|
          if @matrice[j][i]
            rect1 = Rect.new(21 * i, 21 * j, 21, 21)
            rect2 = Rect.new(21 * i + 1, 21 * j + 1, 19, 19)
            self.bitmap.fill_rect(rect1, Color.new(0, 255, 255))
            self.bitmap.fill_rect(rect2, @couleur)
          end
        end
      end
    end
    
    def move_left
      @undo = proc {move_right}
      self.x -= 21
    end
    
    def move_right
      @undo = proc {move_left}
      self.x += 21
    end
    
    def rotate_right
      @undo = proc {rotate_left}
      piece = [[],[],[],[]]
      4.times do |i|
        4.times do |j|
          piece[i][j] = @matrice[3 - j][i]
        end
      end
      @matrice = piece
      refresh
    end
    
    def rotate_left
      @undo = proc {rotate_right}
      piece = [[],[],[],[]]
      4.times do |i|
        4.times do |j|
          piece[i][j] = @matrice[j][3 - i]
        end
      end
      @matrice = piece
      refresh
    end
    
    def move
      @undo = proc {self.y -= 21}
      self.y += 21
    end
    
    def undo
      @undo.call
    end
  end

#=======================================================================
#Affichage du score
#=======================================================================
  class Score < Window_Base
    def initialize
      super(ECRAN_SCORE.x, ECRAN_SCORE.y, ECRAN_SCORE.width, ECRAN_SCORE.height)
      self.contents = Bitmap.new(self.width - 32, self.height - 32)
      self.contents.font = Font.new($fontface , 24)
      self.contents.font.color = Color.new(255, 255, 0)
      self.opacity = 180
      self.z = 2
      refresh
    end
    
    def refresh
      self.contents.clear
      self.contents.draw_text(0, 0, 200, 30, "Nivel : #{Tetris.niveau}")
      self.contents.draw_text(0, 30, 200, 30, "Lineas : #{Tetris.ligne}")
      self.contents.draw_text(0, 60, 200, 30, "Puntaje : #{Tetris.score}")
    end
    
    def niveau(l)
      Tetris.niveau(1) if Tetris.ligne / 10 != Tetris.ligne(l) / 10
      Tetris.score(10 * l * (l + 1) / 2)
      refresh
    end
  end
  
#======================================================================
#fenetre pour afficher la piece suivante
#======================================================================
  class Window_Piece < Window_Base
    def initialize
      super(ECRAN_PIECE.x, ECRAN_PIECE.y, ECRAN_PIECE.width, ECRAN_PIECE.height)
      self.opacity = 180
      self.z = 2
    end    
  end
  
#=======================================================================
#Fenetre de fin du jeu
#=======================================================================
  class Window_Fin < Window_Base
    def initialize
      super(150, 100, 300, 100)
      self.contents = Bitmap.new(self.width - 32, self.height - 32)
      self.contents.font = Font.new($fontface, 40)
      self.contents.font.color = Color.new(255, 255, 0)
      self.z = 10
      refresh
    end
    
    def refresh
      self.contents.clear
      self.contents.draw_text(0, 14, self.width - 32, 40, "Puntaje : #{Tetris.score}", 1)
    end
  end
  
#=======================================================================
#Scene du jeu
#=======================================================================
  class Scene_Jeu
    def initialize(niveau = 1)
      @ecran_jeu = Sprite.new(ECRAN_JEU)
      @ecran_jeu.bitmap = Bitmap.new(210, 462)
      @window_piece = Window_Piece.new
      bgm_play = "mario"
      unless FOND_ECRAN == nil
        @fond = Plane.new
        @fond.bitmap = Bitmap.new("Graphics/Pictures/amigo")
        @fond.z = -1
      end      
      @piece = Piece.new
      @suivante = Piece.new
      @suivante.visible = false
      @window_piece.contents = @suivante.bitmap
      @puit = Array.new(24)
     24.times do |y|
        @puit[y] = Array.new(12, false)
        @puit[y][0] = @puit [y][11] = true
      end
      12.times do |x|
        @puit[22][x] = @puit[23][x] = true
      end
      afficher_puit
      @vitesse = 0.75**niveau
      @temps = Time.new
      Tetris.niveau(niveau)
      @ligne = 0
      @score = Score.new
    end
    
    def main
      Graphics.transition
      loop do
        Graphics.update
        Input.update
        update
        break if $scene != self
      end
      @piece.dispose
      @score.dispose
      @fond.dispose unless FOND_ECRAN == nil
      @suivante.dispose
      @ecran_jeu.dispose
      @murs.dispose
      @window_piece.dispose
    end
    
    def update
      @piece.move_left if Input.repeat?(Input::LEFT)
      @piece.move_right if Input.repeat?(Input::RIGHT)
      @piece.rotate_left if Input.trigger?(Input::C)
      @piece.undo if test_piece
      
      game_over if Input.trigger?(Input::B)
      
      if Input.press?(Input::DOWN)
        Graphics.update
        Graphics.update
        @temps = Time.new
        @piece.move
        pose_piece if test_piece
      elsif (Time.new - @temps) > @vitesse
        @temps = Time.new
        @piece.move
        pose_piece if test_piece
      end
    end
    
#=======================================================================
#Affiche le puit
#=======================================================================
    def afficher_puit
      @murs = Sprite.new
      @murs.bitmap = Bitmap.new(252,483)
      @murs.x = ECRAN_JEU.rect.x - 21
      @murs.y = ECRAN_JEU.rect.y
      @murs.z = 1
      23.times do |y|
        @murs.bitmap.fill_rect(0, 21 * y, 21, 21, Color.new(136, 92, 189))
        @murs.bitmap.fill_rect(1, 21 * y + 1, 19, 19, Color.new(67, 210, 154))
        @murs.bitmap.fill_rect(231, 21 * y, 21, 21, Color.new(136, 92, 189))
        @murs.bitmap.fill_rect(232, 21 * y + 1, 19, 19, Color.new(67, 210, 154))
      end
      for x in 1..10
        @murs.bitmap.fill_rect(21 * x, 462, 21, 21, Color.new(136, 92, 189))
        @murs.bitmap.fill_rect(21 * x + 1, 463, 19, 19, Color.new(67, 210, 154))
      end
    end

#=======================================================================
#Teste si la piece est bien placé
#=======================================================================
    def test_piece
      x = @piece. x / 21 + 1
      y = @piece.y / 21
      4.times do |j|
        4.times do |i|
          return true if @piece.matrice[ j][i] and @puit[y + j][x + i]
        end
      end
      return false
    end

#=======================================================================
#Pose la piece
#=======================================================================
    def pose_piece
      @piece.undo
      @ecran_jeu.bitmap.blt(@piece.x, @piece.y, @piece.bitmap, Rect.new(0, 0, 84, 84))
      x = @piece. x / 21 + 1
      y = @piece.y / 21
      4.times do |j|
        4.times do |i|
          @puit[y + j][x + i] = true if @piece.matrice[j][i]
        end
      end
      count = 0
      for i in y..[y + 4, 21].min  do
        if test_ligne(i)
          supprime_ligne(i)
          count += 1
        end
      end
      @score.niveau(count)
      @vitesse = 0.75**Tetris.niveau
      @piece.dispose
      @piece = @suivante
      @piece.visible = true
      if test_piece
        @piece.undo
        game_over
      end
      @suivante = Piece.new
      @suivante.visible = false
      @window_piece.contents = @suivante.bitmap
    end
    
#=======================================================================
#teste si une ligne est complété
#=======================================================================
    def test_ligne(y)
      r = true
      for x in 1..10 do
        unless @puit[y][x]
          r = false
          break
        end
      end
      return r
    end

#=======================================================================
#Supprime une ligne
#========================================================================
    def supprime_ligne(ligne)
      y = ligne * 21
      image = Bitmap.new(210, 462)
      image.blt(0, 21, @ecran_jeu.bitmap, Rect.new(0, 0, 210, y))
      image.blt(0, y + 21, @ecran_jeu.bitmap, Rect.new(0, y + 21, 210, 451 - y))
      @ecran_jeu.bitmap.clear
      @ecran_jeu.bitmap.blt(0, 0, image, Rect.new(0, 0, 210, 462))
      tableau = Array.new(24)
      24.times {|l| tableau[l] = Array.new(12, false)}
      24.times do |j|
        12.times do |i|
          if j < ligne
            tableau[j + 1][i] = @puit[j][i]
          elsif j > ligne
            tableau[j][i] = @puit[j][i]
          end
        end
      end
      tableau[0][0] = tableau [0][11] = true
      @puit = tableau
    end
    
    def game_over
      @window = Window_Fin.new
      loop do
        Graphics.update
        Input.update
        break if Input.trigger?(Input::C)
      end
      $scene = Scene_Map.new
      @window.dispose
    end
  
  end
end

-Creditos:
Dubriel
 
Mensajes
9.007
Reacciones
224
Puntos
0
Ubicación
00 Qan[T]
-Nombre Del Script:SCRIPT DE ALQUIMIA
-Version Del Script:1.0
-Rpg Maker:XP

-Introducion:
Su función es devolver una serie de objetos al combinar otra serie de objeto. Por ejemplo: mezclamos dos "Poción" con una "Super Poción" y obtenemos dos "Super Poción". Esto es solo un ejemplo, pero se pueden crear infinidad de fórmulas y combinaciones. Además, se puede restringir el tipo de objetos a mezclar, de forma que solo se pueda utilizar en la mezcla los objetos que lleven el atributo X.

-Caracteristicas
Capacidad de utilizar infinidad de fórmulas.
Puedes añadir tantos ingredientes o resultados a una fórmula como te apetezca.
Puedes hacer que sólo ciertos objetos puedan utilizarse en la mezc

-Demo:
http://files.filefront.com/Alquimiaexe/;11779408;/fileinfo.html

-ScreenShot:

1093816capt1.png

http://s2.subirimagenes.com/imagen/1093816capt1.png

1093826capt2.png

http://s2.subirimagenes.com/imagen/1093826capt2.png

-Script

Código:
#-------------------------------------------------------------------------
# Script de alquimia
#-------------------------------------------------------------------------
#  - Versión: 1.1
#  - Autor: Alnain (no son necesarios créditos)
#  - Creado: 11 - 9 - 08 (dd - mm - aa)
#  - Instrucciones: 
#      · Pegar encima de main. 
#      · Para ir a la pantalla de alquimia usa lo siguiente en un llamar 
#      script: $scene = Scene_Alquimia.new.
#      · Selecciona el atributo ingrediente para los objetos que quieras que
#      combinables
#      · Edita la parte editabe a tu gusto.

class Scene_Alquimia # no editar esta línea
  #-------------------------------------------------------------------------
  #----EDITABLE DESDE AQUI -------------------------------------------------
  #-------------------------------------------------------------------------
  def initialize
    
  # Id del atributo "Ingrediente" (editable)
  $atr_ingrediente = 17
  
  #---Combinaciones-----
  @combinaciones = { # no editar esta línea
  
  # Las comabinaciones se definen así:
  #
  # [ingrediente, ingrediente, ingrediente] => [resultado, resultado],
  # 
  # La última combinación no debe llevar la coma al final.
  # Ingrediente y resultado son IDs de objetos en la base de datos.
  # Puedes crear tantas combinaciones como quieras.
  # Puedes añadir tantos ingredientes como quieras a cada combinación.
  # Puedes añadir tantos resultados como quieras a cada combinación.
  
  [33, 34] => [11, 11],
  [35, 37] => [15, 22],
  [34, 38, 39] => [12],
  [35, 37, 40] => [13]
  
  } # no editar esta línea
  
  #-------------------------------------------------------------------------
  #----EDITABLE HASTA AQUI -------------------------------------------------
  #-------------------------------------------------------------------------
end
  def main
    @items_window = Window_Items.new
    @items_window.y = 64
    @mezcla_window = Window_Mezcla.new
    @mezcla_window.x = 320
    @mezcla_window.y = 64
    @mezcla_window.active = false
    @command_window = Window_Inst.new
    @command_window.x = 320
    @command_window.y = 384
    @info_window = Window_Info.new
    @info_window.x = 320 - @info_window.width / 2
    @info_window.y = 240 - @info_window.height / 2
    @info_window.z = 9999
    @info_window.visible = false
    @info_window.set_info
    @description_window = Window_Help.new
    if not @items_window.item.nil?
      @description_window.set_text (@items_window.item.description)
    end

    Graphics.transition
    loop do
      Graphics.update
      Input.update
      update
      if $scene != self
        break
      end
    end
    Graphics.freeze
    #disposes
    @items_window.dispose
    @mezcla_window.dispose
    @command_window.dispose
    @description_window.dispose
  end
  
  def update
    @items_window.update
    @mezcla_window.update
    
      if @items_window.active
        if not @items_window.item.nil?
          @description_window.set_text (@items_window.item.description)
        else
          @description_window.set_text ("")
        end
      else
        if not @mezcla_window.item.nil?
          item = $data_items[@mezcla_window.item]
          @description_window.set_text (item.description)
        else
          @description_window.set_text ("")
        end
      end

    if Input.trigger? (Input::LEFT)
      if @mezcla_window.active
        @mezcla_window.active = false
        @items_window.active = true
      end
    elsif Input.trigger? (Input::RIGHT)
      if @items_window.active
        @mezcla_window.active = true
        @items_window.active = false
      end
    end
    
    if Input.trigger? (Input::C)
      if @items_window.active and not @items_window.item.nil?
        @mezcla_window.añadir_ingrediente (@items_window.item.id)
        @mezcla_window.refresh
        $game_party.lose_item (@items_window.item.id, 1)
        @items_window.index = [0, @items_window.index - 1].max
        @items_window.refresh
      elsif @mezcla_window.active and not @mezcla_window.item.nil?
        $game_party.gain_item (@mezcla_window.item, 1)
        @items_window.refresh
        @mezcla_window.quitar_ingrediente
        @mezcla_window.index = [0, @mezcla_window.index - 1].max
        @mezcla_window.refresh
      else
        @items_window.active = true
        @info_window.visible = false
      end
    end
    
    if Input.trigger? (Input::X)
      vaciar (true)
    elsif Input.trigger? (Input::A)
      mezclar
    end
    
    if Input.trigger? (Input::B)
      vaciar (true)
      $scene = Scene_Map.new
    end
    
  end
  
  def vaciar (devolver)
    items = @mezcla_window.items
    for item in items
      $game_party.gain_item (item, 1) if devolver
      @mezcla_window.quitar_ingrediente
    end
    @mezcla_window.refresh
    @items_window.refresh
  end
  
  def mezclar
    existe = false
    for combinacion in @combinaciones.keys
      if @mezcla_window.items == combinacion.sort
        existe = true
      end
    end
    if existe
      resultado = @combinaciones[@mezcla_window.items]
      for item in resultado 
        $game_party.gain_item (item, 1)
      end
    else
      resultado = []
    end
    vaciar (false)
    @items_window.active = false
    @mezcla_window.active = false
    @info_window.visible = true
    @info_window.set_info (resultado)
  end
  
end


class Window_Info < Window_Base
  
  def initialize
    super (0, 0, 320, 128)
    self.contents = Bitmap.new (width - 32, height - 32)
    self.contents.font.size = 20
  end
  #--------------------------------------------------------------------------
  def set_info (info = [])
    self.contents.clear
#   self.contents.fill_rect (0, 0, self.width, self.height, Color.new (0, 0, 0, 0))
    if info.empty?
      txt = "Combinación equivocada"
      self.contents.draw_text (0, 0, self.width - 32, 32, txt, 1)
      txt = "Has perdido los ingredientes"
      self.contents.draw_text (0, 48, self.width - 32, 32, txt, 1)
      return
    end
    resultados = {}
    for item in info
      if resultados.has_key? (item)
        resultados[item] += 1
      else
        resultados[item] = 1
      end
    end
    self.height = resultados.keys.size * 32 + 32 + 32 + 16
    self.contents = Bitmap.new (width - 32, height - 32)
    txt = "Has obtenido:"
    self.contents.draw_text (0, 0, self.width - 32, 32, txt, 1)
    for i in 0...resultados.keys.size
      item_id = resultados.keys[i]
      item = $data_items[item_id]
      number = resultados[item_id]
      x = 0
      y = 32 + 16 + 32 * i
      bitmap = RPG::Cache.icon(item.icon_name)
      self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24))
      self.contents.draw_text(x + 28, y, 212, 32, item.name, 0)
      self.contents.draw_text(x + 240, y, 16, 32, ":", 1)
      self.contents.draw_text(x + 256, y, 24, 32, number.to_s, 2)
    end
  end
  #--------------------------------------------------------------------------
  def draw_item(data, pos)
  end
  #--------------------------------------------------------------------------
end


class Window_Inst < Window_Base
  
  def initialize
    super (0, 0, 320, 96)
    self.contents = Bitmap.new (width - 32, height - 32)
    refresh
  end
  
  def refresh
    self.contents.clear
    self.contents.draw_text (0, 0, self.width - 32, 32, "A: Vaciar")
    self.contents.draw_text (0, 32, self.width - 32, 32, "Z: Mezclar")
  end
  
end

#==============================================================================
# â–  Window_Item
#------------------------------------------------------------------------------

class Window_Mezcla < Window_Selectable
  #--------------------------------------------------------------------------
  def initialize
    super(0, 0, 320, 320)
    self.contents = Bitmap.new(width - 32, height - 32)
    self.contents.font.name = $fontface
    self.contents.font.size = $fontsize
    @items = {}
    @column_max = 1
    refresh
    self.index = 0
  end
  #--------------------------------------------------------------------------
  def añadir_ingrediente (item)
    if @items[item].nil?
      @items[item] = 1
    else
      @items[item] += 1
    end
  end
  #--------------------------------------------------------------------------
  def quitar_ingrediente 
    @items[item] -= 1
    if @items[item] == 0
      @items.delete (item)
    end
  end
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    @item_max = @items.keys.size
      for i in [email protected]
        if not @items.keys[i].nil?
          draw_item(@items.keys[i], i)
        end
      end
  end
  #--------------------------------------------------------------------------
  def draw_item(data, pos)
    item = $data_items[data]
    number = @items[item.id]
    x = 0
    y = 32 * pos
    bitmap = RPG::Cache.icon(item.icon_name)
    self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24))
    self.contents.draw_text(x + 28, y, 212, 32, item.name, 0)
    self.contents.draw_text(x + 240, y, 16, 32, ":", 1)
    self.contents.draw_text(x + 256, y, 24, 32, number.to_s, 2)
  end
  #--------------------------------------------------------------------------
  def items
    items = []
    for item in @items.keys
      for g in 1..@items[item]
        items.push (item)
      end
    end
    return items
  end
  #--------------------------------------------------------------------------
  def item
    return @items.keys[self.index]
  end
  #--------------------------------------------------------------------------
end

#==============================================================================
# â–  Window_Item
#------------------------------------------------------------------------------

class Window_Items < Window_Selectable
  #--------------------------------------------------------------------------
  def initialize
    super(0, 0, 320, 416)
    self.contents = Bitmap.new(width - 32, height - 32)
    self.contents.font.name = $fontface
    self.contents.font.size = $fontsize
    @column_max = 1
    refresh
    self.index = 0
  end
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    @data = []
    for i in 1...$data_items.size
      if $game_party.item_number(i) > 0 and
        $data_items[i].element_set.include? ($atr_ingrediente)
        @data.push($data_items[i])
      end
    end
    @item_max = @data.size
    if @item_max > 0
      for i in [email protected]
        draw_item(@data[i], i) if not @data[i].nil?
      end
    end
  end
  #--------------------------------------------------------------------------
  def draw_item(data, pos)
    item = data
    number = $game_party.item_number(item.id)
    x = 0
    y = 32 * pos
    bitmap = RPG::Cache.icon(item.icon_name)
    self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24))
    self.contents.draw_text(x + 28, y, 212, 32, item.name, 0)
    self.contents.draw_text(x + 240, y, 16, 32, ":", 1)
    self.contents.draw_text(x + 256, y, 24, 32, number.to_s, 2)
  end
  #--------------------------------------------------------------------------
  def item
    return @data[self.index]
  end
  #--------------------------------------------------------------------------
end

-Instrucciones

· Pegar encima de main.
· Para ir a la pantalla de alquimia usa lo siguiente en un llamar script: $scene = Scene_Alquimia.new.
· Elige la id del atributo que señala que un objeto es utilizable para combinar.
· Edita la parte editable y crea las fórmulas posibles.

-creditos
Alnain
 
Mensajes
332
Reacciones
0
Puntos
0
Ubicación
España
NOMBRE: Bonus de batalla
VERSIÓN: 1.0
RPGMAKER: vx rgss2


Descripción:
Este script se basa en el sistema de Bonus de Batalla de Star Ocean 3. Cuando se rellena el indicador bonus con ciertas acciones como usar una habilidad o matar a un enemigo, el grupo entra en el modo Bonus de Batalla y gana bonus mientras esté lleno el indicador. El bonus puede detenerse si un miembro del grupo muere o es alcanzado por un golpe crítico.

Screen:

vxbonusbattles2rm4.png


Script:

Código:
#==============================================================================
# ** Bonus de Batalla
#------------------------------------------------------------------------------
#  © Dargor, 2008
#  09/08/08
#  Versión 1.0
#------------------------------------------------------------------------------
#  HISTORIAL DE LA VERSIÓN:
#   - 1.0 (09/08/08), Lanzamiento inicial
#------------------------------------------------------------------------------
#  INTRODUCCIÓN:
#     Este script se basa en el sistema de Bonus de Batalla de Star Ocean 3.
#     Cuando se rellena el indicador bonus con ciertas acciones como
#     usar una habilidad o matar a un enemigo, el grupo entra en el
#     modo Bonus de Batalla y gana bonus mientras esté lleno el indicador.
#     El bonus puede detenerse si un miembro del grupo muere o es alcanzado
#     por un golpe crítico.
#------------------------------------------------------------------------------
#  INSTRUCCIONES:
#   - Coloca este script sobre Main
#   - Edita las constantes en el módulo Bonus_Battles  
#------------------------------------------------------------------------------
#  NOTAS:
#   - Este script solo soporta 4 tipos de bonus
#      1) Doble Oro
#      2) Doble EXP
#      3) Aumenta la probabilidad de obtener objeto
#      4) Aumenta la probabilidad de golpes preventivos
#==============================================================================

# Vocabulario
Vocab::BonusBattle = '¡BONUS DE BATALLA!'

#==============================================================================
# ** Módulo de Configuración del Bonus de Batalla
#==============================================================================

module Bonus_Battles
 # La tasa máxima (en porcentaje) que puede alcanzar el indicador
 Max_Rate = 300
 # La cantidad máxima de puntos que se necesitan para llenar el indicador
 Gauge_Max = 100
 # Colores del indicador
 Gauge_Color_1 = 29
 Gauge_Color_2 = 28
 Back_Color = 19
 # Tiempo (en segundos) antes de que el bonus caiga
 Decrease_Time = 2
 # Efectos de sonido
 Gauge_Filled_SE = 'Heal1'
 Gauge_Break_SE = 'Battle2'
 Bonus_Battle_ME = 'Fanfare1'
 Play_Bonus_Battle_ME = false
 # Puntos de Bonus ganados
 Attack_Points = 1
 Skill_Points = 2
 Critical_Points = 4
 Kill_Points = 8
 # Ganar bonus automáticamente en Bonus de Batalla
 Auto_Gain_Bonus = true
 # Orden de bonus auto-ganado
 Auto_Order = [1,3,4,2]
 # Gana un bonus cada X batallas encadenadas
 # (Sólo funciona si Auto_Gain_Bonus = true)
 Bonus_Chain = 5
 # Multiplicador Preventivo (Cuando el grupo tiene el Bonus Preventivo)
 # Los preventivos/por sorpresa originales de VX dependen del nivel medio
 # de agilidad. Si la media de agilidad del grupo es mayor que la media
 # de agilidad del equipo enemigo:
 # Probabilidad Preventivo = 5%, Probabilidad por Sorpresa = 3%
 # Si la media de agilidad del enemigo es mayor que la media
 # de agilidad del grupo:
 # Probabilidad Preventivo = 3%, Probabilidad por Sorpresa = 5%
 Preemptive_Multiplier = 4
end

#==============================================================================
# ** Sonido
#------------------------------------------------------------------------------
#  Este módulo reproduce efectos de sonido. Obtiene los efectos especificados
# en la base de datos desde $data_system, y los reproduce.
#==============================================================================

module Sound
 # Indicador de Bonus de Batalla Vacío
 def self.play_gauge_break
   se = RPG::SE.new(Bonus_Battles::Gauge_Break_SE)
   se.play
 end
 # Indicador de Bonus de Batalla Relleno
 def self.play_gauge_filled
   se = RPG::SE.new(Bonus_Battles::Gauge_Filled_SE)
   se.play
 end
end

#==============================================================================
# ** SRPG::Enemigo::DejarObjeto
#==============================================================================

module RPG
 class Enemy
   class DropItem
     #------------------------------------------------------------------------
     # * Denominador
     #------------------------------------------------------------------------
     def denominator
       if $game_party.increase_items?
         return @denominator / 2
       else
         return @denominator
       end
     end
   end
 end
end

#==============================================================================
# ** Game_Unit
#------------------------------------------------------------------------------
#  This class handles units. It's used as a superclass of the Game_Party and
# Game_Troop classes.
#==============================================================================

class Game_Unit
 #--------------------------------------------------------------------------
 # * Object Initialization
 #--------------------------------------------------------------------------
 def total_agi
   result = 0
   for member in members
     result += member.agi
   end
   return result
 end
end

#==============================================================================
# ** Game_System
#------------------------------------------------------------------------------
#  This class handles system-related data. Also manages vehicles and BGM, etc.
# The instance of this class is referenced by $game_system.
#==============================================================================

class Game_Party
 #--------------------------------------------------------------------------
 # * Public Instance Variables
 #--------------------------------------------------------------------------
 attr_accessor :bonus_battles
 attr_accessor :bonus_gauge
 attr_accessor :last_bonus_gauge
 attr_accessor :battle_bonuses
 attr_accessor :gauge_rate
 #--------------------------------------------------------------------------
 # * Alias Listing
 #--------------------------------------------------------------------------
 alias dargor_vx_bonus_gauge_party_initialize initialize
 alias dargor_vx_bonus_gauge_party_average_agi average_agi
 #--------------------------------------------------------------------------
 # * Object Initialization
 #--------------------------------------------------------------------------
 def initialize
   dargor_vx_bonus_gauge_party_initialize
   @bonus_battles = 0
   @bonus_gauge = 20
   @battle_bonuses = []
   @last_bonus_gauge = @bonus_gauge
   @gauge_rate = 200
 end
 #--------------------------------------------------------------------------
 # * Add Battle Bonus
 #--------------------------------------------------------------------------
 def add_battle_bonus(type)
   return unless can_add_bonus?
   if !@battle_bonuses.empty? &&
       (Bonus_Battles::Auto_Gain_Bonus or type == 0)
     auto_add_battle_bonus
   else
     @battle_bonuses << type
   end
   @battle_bonuses.sort!
   @battle_bonuses.uniq!
 end
 #--------------------------------------------------------------------------
 # * Auto Add Battle Bonus
 #--------------------------------------------------------------------------
 def auto_add_battle_bonus
   for i in Bonus_Battles::Auto_Order
     if !@battle_bonuses.include?(i)
       @battle_bonuses << i
       return
     end
   end
 end
 #--------------------------------------------------------------------------
 # * Can Add Battle Bonus?
 #--------------------------------------------------------------------------
 def can_add_bonus?
   if @battle_bonuses.size == 0
     result = Integer(@bonus_gauge) >= Bonus_Battles::Gauge_Max
     @bonus_gauge = [@bonus_gauge, Bonus_Battles::Gauge_Max].min
     return result
   elsif @bonus_battles > 0
     result = @bonus_battles % Bonus_Battles::Bonus_Chain == 0
     return result
   end
   return false
 end
 #--------------------------------------------------------------------------
 # * Get Adjusted Gauge Rate
 #--------------------------------------------------------------------------
 def get_adjusted_gauge_rate
   agi_total = [average_agi, $game_troop.average_agi]
   agi_min = agi_total.min
   agi_max = agi_total.max
   difference = (agi_min * 100) / agi_max
   if average_agi >= $game_troop.average_agi
     difference -= 1 until difference % 10 == 0
     rate = 100 - ((difference / 2) + ($game_party.members.size * 10))
   else
     difference += 1 until difference % 10 == 0
     rate = 100 + ((difference / 2) + ($game_troop.members.size * 10))
   end
   rate = [[rate, Bonus_Battles::Max_Rate].min, 0].max
   return rate
 end
 #--------------------------------------------------------------------------
 # * Calculate Average Agility
 #--------------------------------------------------------------------------
 def average_agi
   result = dargor_vx_bonus_gauge_party_average_agi
   result *= 2 if increase_preemptive?
   return result
 end
 #--------------------------------------------------------------------------
 # * Increase Gold Bonus
 #--------------------------------------------------------------------------
 def increase_gold?
   return @battle_bonuses.include?(1)
 end
 #--------------------------------------------------------------------------
 # * Increase EXP Bonus
 #--------------------------------------------------------------------------
 def increase_exp?
   return @battle_bonuses.include?(2)
 end
 #--------------------------------------------------------------------------
 # * Increase Items Bonus
 #--------------------------------------------------------------------------
 def increase_items?
   return @battle_bonuses.include?(3)
 end
 #--------------------------------------------------------------------------
 # * Increase Preemptive Bonus
 #--------------------------------------------------------------------------
 def increase_preemptive?
   return @battle_bonuses.include?(4)
 end
end

#==============================================================================
# ** Game_Enemy
#------------------------------------------------------------------------------
#  This class handles enemy characters. It's used within the Game_Troop class
# ($game_troop).
#==============================================================================

class Game_Enemy < Game_Battler
 #--------------------------------------------------------------------------
 # * ALias Listing
 #--------------------------------------------------------------------------
 alias dargor_vx_bonus_battle_enemy_exp exp
 alias dargor_vx_bonus_battle_enemy_gold gold
 #--------------------------------------------------------------------------
 # * Get Experience
 #--------------------------------------------------------------------------
 def exp
   result = dargor_vx_bonus_battle_enemy_exp
   result *= 2 if $game_party.increase_exp?
   return result
 end
 #--------------------------------------------------------------------------
 # * Get Gold
 #--------------------------------------------------------------------------
 def gold
   result = dargor_vx_bonus_battle_enemy_gold
   result *= 2 if $game_party.increase_gold?
   return result
 end
end

#==============================================================================
# ** Sprite_BonusGauge
#------------------------------------------------------------------------------
#  This sprite is used to display the bonus gauge on the battle screen.
#  It observes the $game_system bonus gauge variables and automatically
#  changes sprite conditions.
#==============================================================================

class Sprite_BonusGauge < Sprite
 #--------------------------------------------------------------------------
 # * Public Instance Variables
 #--------------------------------------------------------------------------
 attr_accessor :rate_sprite
 attr_accessor :chain_sprite
 #--------------------------------------------------------------------------
 # * Object Initialization
 #     viewport : viewport
 #--------------------------------------------------------------------------
 def initialize(viewport)
   super(viewport)
   self.bitmap = Bitmap.new(92, 268)
   self.x = 544 - self.bitmap.width
   self.y = 16
   self.z = 200
   # Create a seperate sprite for Bonus Rate
   @rate_sprite = Sprite.new(viewport)
   @rate_sprite.bitmap = Bitmap.new(88,24)
   @rate_sprite.x = self.x
   @rate_sprite.y = 264
   @rate_sprite.z = self.z + 1
   # Create a seperate sprite for Chain Battles
   @chain_sprite = Sprite.new(viewport)
   @chain_sprite.bitmap = Bitmap.new(128,24)
   @chain_sprite.x = self.x
   @chain_sprite.y = 0
   @chain_sprite.z = self.z + 1
   @last_color = text_color(0)
   refresh
 end
 #--------------------------------------------------------------------------
 # * Dispose
 #--------------------------------------------------------------------------
 def dispose
   super
   self.bitmap.dispose
   @rate_sprite.dispose
   @chain_sprite.dispose
 end
 #--------------------------------------------------------------------------
 # * Refresh
 #--------------------------------------------------------------------------
 def refresh
   self.bitmap.clear
   @rate_sprite.bitmap.clear
   @chain_sprite.bitmap.clear
   self.bitmap.fill_rect(70,0,10,268,gauge_back_color)
   $game_party.bonus_gauge = [$game_party.bonus_gauge, Bonus_Battles::Gauge_Max].min
   bar_height = ($game_party.bonus_gauge * 264) / Bonus_Battles::Gauge_Max
   bar_y = 264 - bar_height + 2
   gc1 = bar_color_1
   gc2 = bar_color_2
   self.bitmap.gradient_fill_rect(72,bar_y,6,bar_height,gc1,gc2,true)
   rate = $game_party.gauge_rate
   case rate
   when 0
     color = knockout_color
   when 10..49
     color = crisis_color
   else
     color = Color.new(255,255,255)
   end
   if color != @last_color
     @rate_sprite.flash(@last_color, 20 * 4)
   end
   @rate_sprite.bitmap.font.color = color
   @rate_sprite.bitmap.draw_text(0,0,88,24,"#{rate}%",2)
   if $game_party.bonus_battles > 0
     chain = $game_party.bonus_battles
     @chain_sprite.bitmap.font.color = text_color(0)
     @chain_sprite.bitmap.draw_text(0,0,32,24,chain,2)
     @chain_sprite.bitmap.font.color = system_color
     @chain_sprite.bitmap.draw_text(0,0,88,24,"Cadena",2)
   end
   @last_color = color
   if $game_party.bonus_gauge == Bonus_Battles::Gauge_Max &&
       $game_party.last_bonus_gauge != Bonus_Battles::Gauge_Max
     Sound.play_gauge_filled
     self.flash(Color.new(255,255,255), 20 * 4)
   end
   if $game_party.bonus_gauge == 0 &&
       $game_party.last_bonus_gauge != 0
     Sound.play_gauge_break
     self.flash(Color.new(255,255,255), 20 * 4)
   end
   $game_party.last_bonus_gauge = $game_party.bonus_gauge
 end
 #--------------------------------------------------------------------------
 # * Frame Update
 #--------------------------------------------------------------------------
 def update
   super
   @rate_sprite.update
   $game_party.bonus_gauge = [$game_party.bonus_gauge, Bonus_Battles::Gauge_Max].min
   if $game_party.bonus_gauge != @points
     refresh
   end
 end
 #--------------------------------------------------------------------------
 # * Get Text Color
 #     n : Text color number  (0-31)
 #--------------------------------------------------------------------------
 def text_color(n)
   windowskin = Cache.system("Window")
   x = 64 + (n % 8) * 8
   y = 96 + (n / 8) * 8
   return windowskin.get_pixel(x, y)
 end
 #--------------------------------------------------------------------------
 # * Get System Text Color
 #--------------------------------------------------------------------------
 def system_color
   return text_color(16)
 end
 #--------------------------------------------------------------------------
 # * Get Crisis Text Color
 #--------------------------------------------------------------------------
 def crisis_color
   return text_color(17)
 end
 #--------------------------------------------------------------------------
 # * Get Knockout Text Color
 #--------------------------------------------------------------------------
 def knockout_color
   return text_color(18)
 end
 #--------------------------------------------------------------------------
 # * Get Gauge First Color
 #--------------------------------------------------------------------------
 def bar_color_1
   return text_color(Bonus_Battles::Gauge_Color_1)
 end
 #--------------------------------------------------------------------------
 # * Get Gauge Second Color
 #--------------------------------------------------------------------------
 def bar_color_2
   return text_color(Bonus_Battles::Gauge_Color_2)
 end
 #--------------------------------------------------------------------------
 # * Get Gauge Background Color
 #--------------------------------------------------------------------------
 def gauge_back_color
   return text_color(Bonus_Battles::Back_Color)
 end
end

#==============================================================================
# ** Sprite_Battler
#------------------------------------------------------------------------------
#  This sprite is used to display battlers. It observes a instance of the
# Game_Battler class and automatically changes sprite conditions.
#==============================================================================

class Game_Battler
 #--------------------------------------------------------------------------
 # * Alias Listing
 #--------------------------------------------------------------------------
 alias dargor_vx_bonus_battles_battler_make_attack_damage_value make_attack_damage_value
 alias dargor_vx_bonus_battles_battler_skill_effect skill_effect
 #--------------------------------------------------------------------------
 # * Calculation of Damage From Normal Attack
 #     attacker : Attacker
 #    The results are substituted for @hp_damage
 #--------------------------------------------------------------------------
 def make_attack_damage_value(attacker)
   dargor_vx_bonus_battles_battler_make_attack_damage_value(attacker)
   if attacker.is_a?(Game_Actor)
     if @critical
       # Do not add points for critical hit if the hit kills the target.
       # Instead, add points for killing the target.
       unless @hp_damage >= self.hp
         points = Bonus_Battles::Critical_Points
         points *= $game_party.gauge_rate.to_f / 100
         $game_party.bonus_gauge += points
         # Gain bonus for filling the bonus gauge with a critical hit
         $game_party.add_battle_bonus(3)
       end
     elsif @hp_damage > 0 or @mp_damage > 0
       # Do not add points for hitting if the hit kills the target.
       # Instead, add points for killing the target.
       unless @hp_damage >= self.hp
         points = Bonus_Battles::Attack_Points
         points *= $game_party.gauge_rate.to_f / 100
         $game_party.bonus_gauge += points
         # Gain bonus for filling the bonus gauge with an attack
         $game_party.add_battle_bonus(1)
       end
     end
   else
     # Break bonus gauge if hit by a critical
     if @critical
       $game_party.bonus_gauge = 0
       $game_party.bonus_battles = 0
       $game_party.battle_bonuses = []
     end
   end
 end
 #--------------------------------------------------------------------------
 # * Apply Skill Effects
 #     user  : Skill user
 #     skill : skill
 #--------------------------------------------------------------------------
 def skill_effect(user, skill)
   dargor_vx_bonus_battles_battler_skill_effect(user, skill)
   if user.is_a?(Game_Actor)
     # Do not add points for using skill if the skill kills the target.
     # Instead, add points for killing the target.
     unless @hp_damage >= self.hp
       points = Bonus_Battles::Skill_Points
       points *= $game_party.gauge_rate.to_f / 100
       $game_party.bonus_gauge += points
       # Gain bonus for filling the bonus gauge with an skill
     $game_party.add_battle_bonus(2)
     end
   end
 end
end

#==============================================================================
# ** Game_Actor
#------------------------------------------------------------------------------
#  This class handles actors. It's used within the Game_Actors class
# ($game_actors) and referenced by the Game_Party class ($game_party).
#==============================================================================

class Game_Actor < Game_Battler
 #--------------------------------------------------------------------------
 # * Alias Listing
 #--------------------------------------------------------------------------
 alias dargor_vx_bonus_battles_actor_perform_collapse perform_collapse
 #--------------------------------------------------------------------------
 # * Perform Collapse
 #--------------------------------------------------------------------------
 def perform_collapse
   dargor_vx_bonus_battles_actor_perform_collapse
   if $game_temp.in_battle and dead?
     $game_party.bonus_gauge = 0
     $game_party.bonus_battles = 0
     $game_party.battle_bonuses = []
   end
 end
end

#==============================================================================
# ** Game_Enemy
#------------------------------------------------------------------------------
#  This class handles enemy characters. It's used within the Game_Troop class
# ($game_troop).
#==============================================================================

class Game_Enemy < Game_Battler
 #--------------------------------------------------------------------------
 # * Alias Listing
 #--------------------------------------------------------------------------
 alias dargor_vx_bonus_battles_enemy_perform_collapse perform_collapse
 #--------------------------------------------------------------------------
 # * Perform Collapse
 #--------------------------------------------------------------------------
 def perform_collapse
   dargor_vx_bonus_battles_enemy_perform_collapse
   if $game_temp.in_battle and dead?
     points = Bonus_Battles::Kill_Points
     points *= $game_party.gauge_rate.to_f / 100
     $game_party.bonus_gauge += points
     # Gain bonus for filling the bonus gauge by killing an enemy
     $game_party.add_battle_bonus(4)
   end
 end
end

#==============================================================================
# ** Spriteset_Battle
#------------------------------------------------------------------------------
#  This class brings together battle screen sprites. It's used within the
# Scene_Battle class.
#==============================================================================

class Spriteset_Battle
 #--------------------------------------------------------------------------
 # * Public Instance Variables
 #--------------------------------------------------------------------------
 attr_accessor  :bonus_gauge
 #--------------------------------------------------------------------------
 # * Create Picture Sprite
 #--------------------------------------------------------------------------
 alias dargor_vx_bonus_battles_spriteset_create_pictures create_pictures
 alias dargor_vx_bonus_battles_spriteset_dispose_pictures dispose_pictures
 alias dargor_vx_bonus_battles_spriteset_update_pictures update_pictures
 #--------------------------------------------------------------------------
 # * Create Picture Sprite
 #--------------------------------------------------------------------------
 def create_pictures
   dargor_vx_bonus_battles_spriteset_create_pictures
   @bonus_gauge = Sprite_BonusGauge.new(@viewport2)
 end
 #--------------------------------------------------------------------------
 # * Dispose of Picture Sprite
 #--------------------------------------------------------------------------
 def dispose_pictures
   dargor_vx_bonus_battles_spriteset_dispose_pictures
   @bonus_gauge.dispose
 end
 #--------------------------------------------------------------------------
 # *Update Picture Sprite
 #--------------------------------------------------------------------------
 def update_pictures
   dargor_vx_bonus_battles_spriteset_update_pictures
   @bonus_gauge.update
 end
end

#==============================================================================
# ** Window_BonusBattle
#------------------------------------------------------------------------------
#  This window displays battle bonuses on the battle screen.
#==============================================================================

class Window_BonusBattle < Window_Base
 #--------------------------------------------------------------------------
 # * Object Initialization
 #--------------------------------------------------------------------------
 def initialize
   super(0, 0, 544, 160)
   self.opacity = 0
   self.openness = 0
   create_back_sprite
   refresh
 end
 #--------------------------------------------------------------------------
 # * refresh
 #--------------------------------------------------------------------------
 def refresh
   self.contents.clear
   self.contents.font.size = 24
   self.contents.font.color = crisis_color
   self.contents.draw_text(0,0,504,WLH,Vocab::BonusBattle,1)
   self.contents.font.size = 20
   self.contents.font.color = normal_color
   return if $game_party.battle_bonuses.size == 0
   for i in 0...$game_party.battle_bonuses.size
     bonus = $game_party.battle_bonuses[i]
     x = i % 1 * 272
     y = i / 1 * WLH
     case bonus
     when 1
       text = 'Doble Oro'
     when 2
       text = 'Doble EXP'
     when 3
       text = 'Aumenta la probabilidad de encontrar objetos'
     when 4
       text = 'Aumenta la probabilidad de ataques preventivos'
     end
     self.contents.draw_text(x,y + WLH,504,WLH,text)
   end
 end
 #--------------------------------------------------------------------------
 # * Create Background Sprite
 #--------------------------------------------------------------------------
 def create_back_sprite
   @back_sprite = Sprite.new
   @back_sprite.bitmap = Cache.system("MessageBack")
   @back_sprite.opacity = openness
   @back_sprite.z = self.z - 1
 end
 #--------------------------------------------------------------------------
 # * Dispose of Background Sprite
 #--------------------------------------------------------------------------
 def dispose_back_sprite
   @back_sprite.dispose
 end
 #--------------------------------------------------------------------------
 # * Update Background Sprite
 #--------------------------------------------------------------------------
 def update_back_sprite
   @back_sprite.opacity = openness
   @back_sprite.update
 end
 #--------------------------------------------------------------------------
 # * Dispose
 #--------------------------------------------------------------------------
 def dispose
   super
   dispose_back_sprite
 end
 #--------------------------------------------------------------------------
 # * Update
 #--------------------------------------------------------------------------
 def update
   super
   update_back_sprite
 end
end

#==============================================================================
# ** Window_Base
#------------------------------------------------------------------------------
#  This is a superclass of all windows in the game.
#==============================================================================

class Window_Base < Window
 #--------------------------------------------------------------------------
 # * Public Instance Variables
 #--------------------------------------------------------------------------
 attr_reader :opening
end

#==============================================================================
# ** Scene_Map
#------------------------------------------------------------------------------
#  This class performs the map screen processing.
#==============================================================================

class Scene_Map < Scene_Base
 #--------------------------------------------------------------------------
 # * Alias Listing
 #--------------------------------------------------------------------------
 alias dargor_vx_bonus_battle_map_preemptive_or_surprise preemptive_or_surprise
 #--------------------------------------------------------------------------
 # * Determine Preemptive Strike and Surprise Attack Chance
 #--------------------------------------------------------------------------
 def preemptive_or_surprise
   if $game_party.increase_preemptive?
     actors_agi = $game_party.average_agi
     enemies_agi = $game_troop.average_agi
     if actors_agi >= enemies_agi
       percent_preemptive = 5 * Bonus_Battles::Preemptive_Multiplier
       percent_surprise = 3
     else
       percent_preemptive = 3 * Bonus_Battles::Preemptive_Multiplier
       percent_surprise = 5
     end
     if rand(100) < percent_preemptive
       $game_troop.preemptive = true
     elsif rand(100) < percent_surprise
       $game_troop.surprise = true
     end
   else
     dargor_vx_bonus_battle_map_preemptive_or_surprise
   end
 end
end

#==============================================================================
# ** Scene_Battle
#------------------------------------------------------------------------------
#  This class performs battle screen processing.
#==============================================================================

class Scene_Battle < Scene_Base
 #--------------------------------------------------------------------------
 # * Alias Listing
 #--------------------------------------------------------------------------
 alias dargor_vx_bonus_battles_battle_start start
 alias dargor_vx_bonus_battles_battle_terminate terminate
 alias dargor_vx_bonus_battles_battle_update_basic update_basic
 alias dargor_vx_bonus_battles_battle_execute_action execute_action
 #--------------------------------------------------------------------------
 # * Start Processing
 #--------------------------------------------------------------------------
 def start
   # Increase bonus battle count
   if $game_party.bonus_gauge == Bonus_Battles::Gauge_Max
     $game_party.bonus_battles += 1
   end
   # Auto-gain bonuses
   $game_party.add_battle_bonus(0)
   # Set gauge rate
   $game_party.gauge_rate = $game_party.get_adjusted_gauge_rate
   # Create bonus window
   @bonus_window = Window_BonusBattle.new
   @bonus_window.open if $game_party.bonus_battles > 0
   @last_party_bonus = $game_party.battle_bonuses
   dargor_vx_bonus_battles_battle_start
 end
 #--------------------------------------------------------------------------
 # * Start Processing
 #--------------------------------------------------------------------------
 def terminate
   dargor_vx_bonus_battles_battle_terminate
   @bonus_window.dispose
 end
 #--------------------------------------------------------------------------
 # * Basic Update Processing
 #     main : Call from main update method
 #--------------------------------------------------------------------------
 def update_basic(main = false)
   @bonus_window.update
   update_bonus_gauge          # Update the bonus gauge
   update_bonus_window         # Update the bonus window
   # Close the bonus window
   if Input.trigger?(Input::C)
     @bonus_window.close
   end
   # The usual
   dargor_vx_bonus_battles_battle_update_basic(main)
 end
 #--------------------------------------------------------------------------
 # * Frame Update (Bonus gauge)
 #--------------------------------------------------------------------------
 def update_bonus_gauge
   if update_bonus_gauge?
     $game_party.gauge_rate = [$game_party.gauge_rate -= 10, 0].max
     @spriteset.bonus_gauge.refresh
   end
 end
 #--------------------------------------------------------------------------
 # * Frame Update (Bonus window)
 #--------------------------------------------------------------------------
 def update_bonus_window
   if ($game_party.bonus_gauge == Bonus_Battles::Gauge_Max &&
       $game_party.last_bonus_gauge != Bonus_Battles::Gauge_Max) or
       ($game_party.battle_bonuses != @last_party_bonus)
     @bonus_window.refresh
     @bonus_window.open
     @bonus_me = RPG::ME.new
     @bonus_me.name = Bonus_Battles::Bonus_Battle_ME
     @bonus_me.play if Bonus_Battles::Play_Bonus_Battle_ME
     if $game_party.battle_bonuses != @last_party_bonus
       @last_party_bonus = $game_party.battle_bonuses
     end
   end
 end
 #--------------------------------------------------------------------------
 # * Update Bonus Gauge?
 #--------------------------------------------------------------------------
 def update_bonus_gauge?
   time = Bonus_Battles::Decrease_Time * 60
   result = true
   result &&= @party_command_window.active == false
   result &&= @message_window.visible == false
   result &&= Graphics.frame_count % time == 0
   return result
 end
end

Instrucciones:
Pégalo encima de Main. Es editable, así que revisa el script para dejarlo a tu gusto.

Lo probe y funciona al 100%
 
Mensajes
9.007
Reacciones
224
Puntos
0
Ubicación
00 Qan[T]
-Nombre Del Script:ccoa's weather script
-Version Del Script:0.1
-Rpg Maker:XP

-Introducion:
Aquí les dejo este fantástico script que les permitirá darle más realismo a sus juegos. Tiene 14 climas predeterminados y uno para configurar.

-Caracteristicas:
Pegar este script en una nueva clase encima de Main. el resto está contenido en el script.

-Script:

Código:
#===========================
# ccoa's weather script
# Creditos a CCoa...
#Completamente traducido por "PrincipeDragon" 
#===========================
#Nota: no se explicar como modificar el script, si no sabes como hacer, simplemente dejalo como estaba, Grax

#Un buen script del clima:
#Los Tipos de tiempo son:  
#1 - la lluvia  
#2 - la tormenta  
#3 - la nieve  
#4 - el granizo  
#5 - la lluvia con el trueno y relámpago  
#6 - las hojas cayentes (otoño)  
#7 - volando las hojas (otoño)  
#8 - las hojas revueltas (otoño)  
#9 - las hojas cayentes (verde)  
#10 - la lozanía de la cereza (el sakura) los pétalos  
#11 - los pétalos de la rosa  
#12 - las plumas  
#13 - la lluvia de sangre  
#14 - las chispas  
#15 - el usuario definió
#
# Poder (Fuerza) del Clima:
# Este tiene que ser un numero entero que varie de 0-40. Ejemplo: 0- Ninguna fuerza,
#40-400 imagenes...
#
# Utilización del Scritps:
# Crea un evento y le das a LLamar Scripts y pones:
# $game_screen.weather(Tipo1-14, Poder 0-40, Color)
#
#Ejemplo:  $game_screen.weather(11, 5, 0)    Esto hara que se activo el tipo numero 11
#los pétalos de la rosa con muy poca fuerza...
#
#Sinceramnete no se decir para que sirve Color, algunas veces o simpre pongo 0, he igual
#funciona...
#
#Para desactivar el script solo tienes que eligir en el panerl de eventos la opcion
#de "Opciones de clima" y seleccionar Ninguno.
#
# Para usar Clima Definido por el Usuario (Si no entiendes ver Demo):
# Mire lo siguiente a continuación:

$WEATHER_UPDATE = false # las $WEATHER_IMAGES, si hanc cambiado 
$WEATHER_IMAGES = [] # entre eso, va el nombre de la imagen que se va a mostrar
$WEATHER_X = 0 # el numero de pixeles que la iamgen se tiene que mover horizontalemente(Nº positivo = Derecho, Nº Negativo = Izquiero)
$WEATHER_Y = 0 # el numero de pixeles que la iamgen se tiene que mover verticalmente (Nº positivo = Abajo, Nº Negativo = Arriba)
$WEATHER_FADE = 0 # En cuento debe aparecer la imagen (0 = no aparece, 255 = intantaneamente)
$WEATHER_ANIMATED = false #Eleciones: Si(true) o No(false). La imagen debe ciclo a través de todas las imágenes
module RPG
class Weather
def initialize(viewport = nil)
@type = 0
@max = 0
@ox = 0
@oy = 0
@count = 0
@current_pose = []
@info = []
@countarray = []

make_bitmaps

# **** ccoa ****
for i in 1..500
sprite = Sprite.new(viewport)
sprite.z = 1000
sprite.visible = false
sprite.opacity = 0
@sprites.push(sprite)
@current_pose.push(0)
@info.push(rand(50))
@countarray.push(rand(15))
end
end

def dispose
for sprite in @sprites
sprite.dispose
end
@rain_bitmap.dispose
@storm_bitmap.dispose
@snow_bitmap.dispose
@hail_bitmap.dispose
@petal_bitmap.dispose
@blood_rain_bitmap.dispose
for image in @autumn_leaf_bitmaps
image.dispose
end
for image in @green_leaf_bitmaps
image.dispose
end
for image in @rose_bitmaps
image.dispose
end
for image in @feather_bitmaps
image.dispose
end
for image in @sparkle_bitmaps
image.dispose
end
for image in @user_bitmaps
image.dispose
end
$WEATHER_UPDATE = true
end

def type=(type)
return if @type == type
@type = type
case @type
when 1 # LLuvia
bitmap = @rain_bitmap
when 2 # Tormenta
bitmap = @storm_bitmap
when 3 # Nieve
bitmap = @snow_bitmap
when 4 # Granizo
bitmap = @hail_bitmap
when 5 # Lluvia mas trueno y relampago
bitmap = @rain_bitmap
@thunder = true
when 6 # las hojas del otoño (cayentes)
bitmap = @autumn_leaf_bitmaps[0]
when 7 # las hojas del otoño (soplando)
bitmap = @autumn_leaf_bitmaps[0]
when 8 # las hojas del otoño (revueltas)
bitmap = @autumn_leaf_bitmaps[0]
when 9 # las hojas verdes (cayéndose)
bitmap = @green_leaf_bitmaps[0]
when 10 # Petalos tipo Sakura
bitmap = @petal_bitmap
when 11 # Petalos Rojos
bitmap = @rose_bitmaps[0]
when 12 # feathers
bitmap = @feather_bitmaps[0]
when 13 # La lluvia de sangre
bitmap = @blood_rain_bitmap
when 14 # Chispas
bitmap = @sparkle_bitmaps[0]
when 15 # Definido por el Usuario
bitmap = @user_bitmaps[rand(@user_bitmaps.size)]
else
bitmap = nil
end
if @type != 5
@thunder = false
end
# **** ccoa ****
for i in 1..500
sprite = @sprites[i]
if sprite != nil
sprite.visible = (i <= @max)
sprite.bitmap = bitmap
end
end
end

def ox=(ox)
return if @ox == ox;
@ox = ox
for sprite in @sprites
sprite.ox = @ox
end
end

def oy=(oy)
return if @oy == oy;
@oy = oy
for sprite in @sprites
sprite.oy = @oy
end
end

def max=(max)
return if @max == max;
# **** ccoa ****
@max = [[max, 0].max, 500].min
for i in 1..500
sprite = @sprites[i]
if sprite != nil
sprite.visible = (i <= @max)
end
end
end

def update
return if @type == 0
for i in 1..@max
sprite = @sprites[i]
if sprite == nil
break
end
if @type == 1 or @type == 5 or @type == 13 # rain
sprite.x -= 2
sprite.y += 16
sprite.opacity -= 8
if @thunder and (rand(8000 - @max) == 0)
$game_screen.start_flash(Color.new(255, 255, 255, 255), 5)
Audio.se_play("Audio/SE/061-Thunderclap01")  # Sonido que se usara como trueno y relampago
end
end
if @type == 2 # Tormenra
sprite.x -= 8
sprite.y += 16
sprite.opacity -= 12
end
if @type == 3 # Nieve
sprite.x -= 2
sprite.y += 8
sprite.opacity -= 8
end
if @type == 4 # Granizo
sprite.x -= 1
sprite.y += 18
sprite.opacity -= 15
end
if @type == 6 # las hojas del otoño cayentes
@count = rand(20)
if @count == 0
sprite.bitmap = @autumn_leaf_bitmaps[@current_pose[i]]
@current_pose[i] = (@current_pose[i] + 1) % @autumn_leaf_bitmaps.size
end
sprite.x -= 1
sprite.y += 1
end
if @type == 7 # las hojas del otoño soplando
@count = rand(20)
if @count == 0
sprite.bitmap = @autumn_leaf_bitmaps[@current_pose[i]]
@current_pose[i] = (@current_pose[i] + 1) % @autumn_leaf_bitmaps.size
end
sprite.x -= 10
sprite.y += (rand(4) - 2)
end
if @type == 8 # las hojas del otoños revueltes
@count = rand(20)
if @count == 0
sprite.bitmap = @autumn_leaf_bitmaps[@current_pose[i]]
@current_pose[i] = (@current_pose[i] + 1) % @autumn_leaf_bitmaps.size
end
if @info[i] != 0
if @info[i] >= 1 and @info[i] <= 10
sprite.x -= 3
sprite.y -= 1
elsif @info[i] >= 11 and @info[i] <= 16
sprite.x -= 1
sprite.y -= 2
elsif @info[i] >= 17 and @info[i] <= 20
sprite.y -= 3
elsif @info[i] >= 21 and @info[i] <= 30
sprite.y -= 2
sprite.x += 1
elsif @info[i] >= 31 and @info[i] <= 36
sprite.y -= 1
sprite.x += 3
elsif @info[i] >= 37 and @info[i] <= 40
sprite.x += 5
elsif @info[i] >= 41 and @info[i] <= 46
sprite.y += 1
sprite.x += 3
elsif @info[i] >= 47 and @info[i] <= 58
sprite.y += 2
sprite.x += 1
elsif @info[i] >= 59 and @info[i] <= 64
sprite.y += 3
elsif @info[i] >= 65 and @info[i] <= 70
sprite.x -= 1
sprite.y += 2
elsif @info[i] >= 71 and @info[i] <= 81
sprite.x -= 3
sprite.y += 1
elsif @info[i] >= 82 and @info[i] <= 87
sprite.x -= 5
end
@info[i] = (@info[i] + 1) % 88
else
if rand(200) == 0
@info[i] = 1
end
sprite.x -= 5
sprite.y += 1
end
end
if @type == 9 # Hojas verdes
if @countarray[i] == 0
@current_pose[i] = (@current_pose[i] + 1) % @green_leaf_bitmaps.size
sprite.bitmap = @green_leaf_bitmaps[@current_pose[i]]
@countarray[i] = rand(15)
end
@countarray[i] = (@countarray[i] + 1) % 15
sprite.y += 1
end
if @type == 10 # petalos tipo sakura
if @info[i] < 25
sprite.x -= 1
else
sprite.x += 1
end
@info[i] = (@info[i] + 1) % 50
sprite.y += 1
end
if @type == 11 # Petalos Rosa (rojo)
@count = rand(20)
if @count == 0
sprite.bitmap = @rose_bitmaps[@current_pose[i]]
@current_pose[i] = (@current_pose[i] + 1) % @rose_bitmaps.size
end
if @info[i] % 2 == 0
if @info[i] < 10
sprite.x -= 1
else
sprite.x += 1
end
end
sprite.y += 1
end
if @type == 12 # Plumas
if @countarray[i] == 0
@current_pose[i] = (@current_pose[i] + 1) % @feather_bitmaps.size
sprite.bitmap = @feather_bitmaps[@current_pose[i]]
end
@countarray[i] = (@countarray[i] + 1) % 15
if rand(100) == 0
sprite.x -= 1
end
if rand(100) == 0
sprite.y -= 1
end
if @info[i] < 50
if rand(2) == 0
sprite.x -= 1
else
sprite.y -= 1
end
else
if rand(2) == 0
sprite.x += 1
else
sprite.y += 1
end
end
@info[i] = (@info[i] + 1) % 100
end
if @type == 14 # Chispas
if @countarray[i] == 0
@current_pose[i] = (@current_pose[i] + 1) % @sparkle_bitmaps.size
sprite.bitmap = @sparkle_bitmaps[@current_pose[i]]
end
@countarray[i] = (@countarray[i] + 1) % 15
sprite.y += 1
sprite.opacity -= 1
end
if @type == 15 # Definido por el usuario
if $WEATHER_UPDATE
update_user_defined
$WEATHER_UPDATE = false
end
if $WEATHER_ANIMATED and @countarray[i] == 0
@current_pose[i] = (@current_pose[i] + 1) % @user_bitmaps.size
sprite.bitmap = @user_bitmaps[@current_pose[i]]
end
@countarray[i] = (@countarray[i] + 1) % 15
sprite.x += $WEATHER_X
sprite.y += $WEATHER_Y
sprite.opacity -= $WEATHER_FADE
end

x = sprite.x - @ox
y = sprite.y - @oy
if sprite.opacity < 64 or x < -50 or x > 750 or y < -300 or y > 500
sprite.x = rand(800) - 50 + @ox
sprite.y = rand(800) - 200 + @oy
sprite.opacity = 255
end
end
end

def make_bitmaps
color1 = Color.new(255, 255, 255, 255)
color2 = Color.new(255, 255, 255, 128)
@rain_bitmap = Bitmap.new(7, 56)
for i in 0..6
@rain_bitmap.fill_rect(6-i, i*8, 1, 8, color1)
end
@storm_bitmap = Bitmap.new(34, 64)
for i in 0..31
@storm_bitmap.fill_rect(33-i, i*2, 1, 2, color2)
@storm_bitmap.fill_rect(32-i, i*2, 1, 2, color1)
@storm_bitmap.fill_rect(31-i, i*2, 1, 2, color2)
end
@snow_bitmap = Bitmap.new(6, 6)
@snow_bitmap.fill_rect(0, 1, 6, 4, color2)
@snow_bitmap.fill_rect(1, 0, 4, 6, color2)
@snow_bitmap.fill_rect(1, 2, 4, 2, color1)
@snow_bitmap.fill_rect(2, 1, 2, 4, color1)
@sprites = []

blueGrey = Color.new(215, 227, 227, 150)
grey = Color.new(214, 217, 217, 150)
lightGrey = Color.new(233, 233, 233, 250)
lightBlue = Color.new(222, 239, 243, 250)
@hail_bitmap = Bitmap.new(4, 4)
@hail_bitmap.fill_rect(1, 0, 2, 1, blueGrey)
@hail_bitmap.fill_rect(0, 1, 1, 2, blueGrey)
@hail_bitmap.fill_rect(3, 1, 1, 2, grey)
@hail_bitmap.fill_rect(1, 3, 2, 1, grey)
@hail_bitmap.fill_rect(1, 1, 2, 2, lightGrey)
@hail_bitmap.set_pixel(1, 1, lightBlue)


color3 = Color.new(255, 167, 192, 255) # Color Rosa Claro
color4 = Color.new(213, 106, 136, 255) # Color Rosa Oscuro
# Estos des colores de usan para los colores de losmpetalos de rosas tipo sakura y rojas.
@petal_bitmap = Bitmap.new(4, 4) #Esto crea un nuevo bitmap que es de 4 x 4 pixeles
@petal_bitmap.fill_rect(0, 3, 1, 1, color3) # esto hace un 1x1 "rectángulo" del pixel a los 0, 3 pixel de la imagen (la esquina izquierda superior es 0, 0)
@petal_bitmap.fill_rect(1, 2, 1, 1, color3)
@petal_bitmap.fill_rect(2, 1, 1, 1, color3)
@petal_bitmap.fill_rect(3, 0, 1, 1, color3)
@petal_bitmap.fill_rect(1, 3, 1, 1, color4)
@petal_bitmap.fill_rect(2, 2, 1, 1, color4)
@petal_bitmap.fill_rect(3, 1, 1, 1, color4)


brightOrange = Color.new(248, 88, 0, 255)
orangeBrown = Color.new(144, 80, 56, 255)
burntRed = Color.new(152, 0, 0, 255)
paleOrange = Color.new(232, 160, 128, 255)
darkBrown = Color.new(72, 40, 0, 255)
@autumn_leaf_bitmaps = []
@autumn_leaf_bitmaps.push(Bitmap.new(8, 8))
# Aqui se dibuja el primero de de los bitmaps de la hoja 1
@autumn_leaf_bitmaps[0].set_pixel(5, 1, orangeBrown)
@autumn_leaf_bitmaps[0].set_pixel(6, 1, brightOrange)
@autumn_leaf_bitmaps[0].set_pixel(7, 1, paleOrange)
@autumn_leaf_bitmaps[0].set_pixel(3, 2, orangeBrown)
@autumn_leaf_bitmaps[0].fill_rect(4, 2, 2, 1, brightOrange)
@autumn_leaf_bitmaps[0].set_pixel(6, 2, paleOrange)
@autumn_leaf_bitmaps[0].set_pixel(2, 3, orangeBrown)
@autumn_leaf_bitmaps[0].set_pixel(3, 3, brightOrange)
@autumn_leaf_bitmaps[0].fill_rect(4, 3, 2, 1, paleOrange)
@autumn_leaf_bitmaps[0].set_pixel(1, 4, orangeBrown)
@autumn_leaf_bitmaps[0].set_pixel(2, 4, brightOrange)
@autumn_leaf_bitmaps[0].set_pixel(3, 4, paleOrange)
@autumn_leaf_bitmaps[0].set_pixel(1, 5, brightOrange)
@autumn_leaf_bitmaps[0].set_pixel(2, 5, paleOrange)
@autumn_leaf_bitmaps[0].set_pixel(0, 6, orangeBrown)
@autumn_leaf_bitmaps[0].set_pixel(1, 6, paleOrange)
@autumn_leaf_bitmaps[0].set_pixel(0, 7, paleOrange)

# Se dibuja el segundo bitmap de la hoja 1
@autumn_leaf_bitmaps.push(Bitmap.new(8, 8))
@autumn_leaf_bitmaps[1].set_pixel(3, 0, brightOrange)
@autumn_leaf_bitmaps[1].set_pixel(7, 0, brightOrange)
@autumn_leaf_bitmaps[1].set_pixel(3, 1, orangeBrown)
@autumn_leaf_bitmaps[1].set_pixel(4, 1, burntRed)
@autumn_leaf_bitmaps[1].set_pixel(6, 1, brightOrange)
@autumn_leaf_bitmaps[1].set_pixel(0, 2, paleOrange)
@autumn_leaf_bitmaps[1].set_pixel(1, 2, brightOrange)
@autumn_leaf_bitmaps[1].set_pixel(2, 2, orangeBrown)
@autumn_leaf_bitmaps[1].set_pixel(3, 2, burntRed)
@autumn_leaf_bitmaps[1].set_pixel(4, 2, orangeBrown)
@autumn_leaf_bitmaps[1].set_pixel(5, 2, brightOrange)
@autumn_leaf_bitmaps[1].fill_rect(1, 3, 3, 1, orangeBrown)
@autumn_leaf_bitmaps[1].fill_rect(4, 3, 2, 1, brightOrange)
@autumn_leaf_bitmaps[1].set_pixel(6, 3, orangeBrown)
@autumn_leaf_bitmaps[1].set_pixel(2, 4, burntRed)
@autumn_leaf_bitmaps[1].fill_rect(3, 4, 3, 1, brightOrange)
@autumn_leaf_bitmaps[1].set_pixel(6, 4, burntRed)
@autumn_leaf_bitmaps[1].set_pixel(7, 4, darkBrown)
@autumn_leaf_bitmaps[1].set_pixel(1, 5, orangeBrown)
@autumn_leaf_bitmaps[1].fill_rect(2, 5, 2, 1, brightOrange)
@autumn_leaf_bitmaps[1].set_pixel(4, 5, orangeBrown)
@autumn_leaf_bitmaps[1].set_pixel(5, 5, burntRed)
@autumn_leaf_bitmaps[1].fill_rect(1, 6, 2, 1, brightOrange)
@autumn_leaf_bitmaps[1].fill_rect(4, 6, 2, 1, burntRed)
@autumn_leaf_bitmaps[1].set_pixel(0, 7, brightOrange)
@autumn_leaf_bitmaps[1].set_pixel(5, 7, darkBrown)

# Se dibuja el tercero bitmap de la hoja 1
@autumn_leaf_bitmaps.push(Bitmap.new(8, 8))
@autumn_leaf_bitmaps[2].set_pixel(7, 1, paleOrange)
@autumn_leaf_bitmaps[2].set_pixel(6, 2, paleOrange)
@autumn_leaf_bitmaps[2].set_pixel(7, 2, orangeBrown)
@autumn_leaf_bitmaps[2].set_pixel(5, 3, paleOrange)
@autumn_leaf_bitmaps[2].set_pixel(6, 3, brightOrange)
@autumn_leaf_bitmaps[2].set_pixel(4, 4, paleOrange)
@autumn_leaf_bitmaps[2].set_pixel(5, 4, brightOrange)
@autumn_leaf_bitmaps[2].set_pixel(6, 4, orangeBrown)
@autumn_leaf_bitmaps[2].fill_rect(2, 5, 2, 1, paleOrange)
@autumn_leaf_bitmaps[2].set_pixel(4, 5, brightOrange)
@autumn_leaf_bitmaps[2].set_pixel(5, 5, orangeBrown)
@autumn_leaf_bitmaps[2].set_pixel(1, 6, paleOrange)
@autumn_leaf_bitmaps[2].fill_rect(2, 6, 2, 1, brightOrange)
@autumn_leaf_bitmaps[2].set_pixel(4, 6, orangeBrown)
@autumn_leaf_bitmaps[2].set_pixel(0, 7, paleOrange)
@autumn_leaf_bitmaps[2].set_pixel(1, 7, brightOrange)
@autumn_leaf_bitmaps[2].set_pixel(2, 7, orangeBrown)

# Se dibuja el cuarto bitmap de la hoja 1
@autumn_leaf_bitmaps.push(Bitmap.new(8, 8))
@autumn_leaf_bitmaps[3].set_pixel(3, 0, brightOrange)
@autumn_leaf_bitmaps[3].set_pixel(7, 0, brightOrange)
@autumn_leaf_bitmaps[3].set_pixel(3, 1, orangeBrown)
@autumn_leaf_bitmaps[3].set_pixel(4, 1, burntRed)
@autumn_leaf_bitmaps[3].set_pixel(6, 1, brightOrange)
@autumn_leaf_bitmaps[3].set_pixel(0, 2, paleOrange)
@autumn_leaf_bitmaps[3].set_pixel(1, 2, brightOrange)
@autumn_leaf_bitmaps[3].set_pixel(2, 2, orangeBrown)
@autumn_leaf_bitmaps[3].set_pixel(3, 2, burntRed)
@autumn_leaf_bitmaps[3].set_pixel(4, 2, orangeBrown)
@autumn_leaf_bitmaps[3].set_pixel(5, 2, brightOrange)
@autumn_leaf_bitmaps[3].fill_rect(1, 3, 3, 1, orangeBrown)
@autumn_leaf_bitmaps[3].fill_rect(4, 3, 2, 1, brightOrange)
@autumn_leaf_bitmaps[3].set_pixel(6, 3, orangeBrown)
@autumn_leaf_bitmaps[3].set_pixel(2, 4, burntRed)
@autumn_leaf_bitmaps[3].fill_rect(3, 4, 3, 1, brightOrange)
@autumn_leaf_bitmaps[3].set_pixel(6, 4, burntRed)
@autumn_leaf_bitmaps[3].set_pixel(7, 4, darkBrown)
@autumn_leaf_bitmaps[3].set_pixel(1, 5, orangeBrown)
@autumn_leaf_bitmaps[3].fill_rect(2, 5, 2, 1, brightOrange)
@autumn_leaf_bitmaps[3].set_pixel(4, 5, orangeBrown)
@autumn_leaf_bitmaps[3].set_pixel(5, 5, burntRed)
@autumn_leaf_bitmaps[3].fill_rect(1, 6, 2, 1, brightOrange)
@autumn_leaf_bitmaps[3].fill_rect(4, 6, 2, 1, burntRed)
@autumn_leaf_bitmaps[3].set_pixel(0, 7, brightOrange)
@autumn_leaf_bitmaps[3].set_pixel(5, 7, darkBrown)

@green_leaf_bitmaps = []
darkGreen = Color.new(62, 76, 31, 255)
midGreen = Color.new(76, 91, 43, 255)
khaki = Color.new(105, 114, 66, 255)
lightGreen = Color.new(128, 136, 88, 255)
mint = Color.new(146, 154, 106, 255)

# 1ª parte del bimap de otro hoja
@green_leaf_bitmaps[0] = Bitmap.new(8, 8)
@green_leaf_bitmaps[0].set_pixel(1, 0, darkGreen)
@green_leaf_bitmaps[0].set_pixel(1, 1, midGreen)
@green_leaf_bitmaps[0].set_pixel(2, 1, darkGreen)
@green_leaf_bitmaps[0].set_pixel(2, 2, khaki)
@green_leaf_bitmaps[0].set_pixel(3, 2, darkGreen)
@green_leaf_bitmaps[0].set_pixel(4, 2, khaki)
@green_leaf_bitmaps[0].fill_rect(2, 3, 3, 1, midGreen)
@green_leaf_bitmaps[0].set_pixel(5, 3, khaki)
@green_leaf_bitmaps[0].fill_rect(2, 4, 2, 1, midGreen)
@green_leaf_bitmaps[0].set_pixel(4, 4, darkGreen)
@green_leaf_bitmaps[0].set_pixel(5, 4, lightGreen)
@green_leaf_bitmaps[0].set_pixel(6, 4, khaki)
@green_leaf_bitmaps[0].set_pixel(3, 5, midGreen)
@green_leaf_bitmaps[0].set_pixel(4, 5, darkGreen)
@green_leaf_bitmaps[0].set_pixel(5, 5, khaki)
@green_leaf_bitmaps[0].set_pixel(6, 5, lightGreen)
@green_leaf_bitmaps[0].set_pixel(4, 6, midGreen)
@green_leaf_bitmaps[0].set_pixel(5, 6, darkGreen)
@green_leaf_bitmaps[0].set_pixel(6, 6, lightGreen)
@green_leaf_bitmaps[0].set_pixel(6, 7, khaki)

# 2ª parte del bimap de otro hoja
@green_leaf_bitmaps[1] = Bitmap.new(8, 8)
@green_leaf_bitmaps[1].fill_rect(1, 1, 1, 2, midGreen)
@green_leaf_bitmaps[1].fill_rect(2, 2, 2, 1, khaki)
@green_leaf_bitmaps[1].set_pixel(4, 2, lightGreen)
@green_leaf_bitmaps[1].fill_rect(2, 3, 2, 1, darkGreen)
@green_leaf_bitmaps[1].fill_rect(4, 3, 2, 1, lightGreen)
@green_leaf_bitmaps[1].set_pixel(2, 4, midGreen)
@green_leaf_bitmaps[1].set_pixel(3, 4, darkGreen)
@green_leaf_bitmaps[1].set_pixel(4, 4, khaki)
@green_leaf_bitmaps[1].fill_rect(5, 4, 2, 1, lightGreen)
@green_leaf_bitmaps[1].set_pixel(3, 5, midGreen)
@green_leaf_bitmaps[1].set_pixel(4, 5, darkGreen)
@green_leaf_bitmaps[1].set_pixel(5, 5, khaki)
@green_leaf_bitmaps[1].set_pixel(6, 5, lightGreen)
@green_leaf_bitmaps[1].set_pixel(5, 6, darkGreen)
@green_leaf_bitmaps[1].fill_rect(6, 6, 2, 1, khaki)

# 3ª parte del bimap de otro hoja
@green_leaf_bitmaps[2] = Bitmap.new(8, 8)
@green_leaf_bitmaps[2].set_pixel(1, 1, darkGreen)
@green_leaf_bitmaps[2].fill_rect(1, 2, 2, 1, midGreen)
@green_leaf_bitmaps[2].set_pixel(2, 3, midGreen)
@green_leaf_bitmaps[2].set_pixel(3, 3, darkGreen)
@green_leaf_bitmaps[2].set_pixel(4, 3, midGreen)
@green_leaf_bitmaps[2].fill_rect(2, 4, 2, 1, midGreen)
@green_leaf_bitmaps[2].set_pixel(4, 4, darkGreen)
@green_leaf_bitmaps[2].set_pixel(5, 4, lightGreen)
@green_leaf_bitmaps[2].set_pixel(3, 5, midGreen)
@green_leaf_bitmaps[2].set_pixel(4, 5, darkGreen)
@green_leaf_bitmaps[2].fill_rect(5, 5, 2, 1, khaki)
@green_leaf_bitmaps[2].fill_rect(4, 6, 2, 1, midGreen)
@green_leaf_bitmaps[2].set_pixel(6, 6, lightGreen)
@green_leaf_bitmaps[2].set_pixel(6, 7, khaki)

# 4ª parte del bimap de otro hoja
@green_leaf_bitmaps[3] = Bitmap.new(8, 8)
@green_leaf_bitmaps[3].fill_rect(0, 3, 1, 2, darkGreen)
@green_leaf_bitmaps[3].set_pixel(1, 4, midGreen)
@green_leaf_bitmaps[3].set_pixel(2, 4, khaki)
@green_leaf_bitmaps[3].set_pixel(3, 4, lightGreen)
@green_leaf_bitmaps[3].set_pixel(4, 4, darkGreen)
@green_leaf_bitmaps[3].set_pixel(7, 4, midGreen)
@green_leaf_bitmaps[3].set_pixel(1, 5, darkGreen)
@green_leaf_bitmaps[3].set_pixel(2, 5, midGreen)
@green_leaf_bitmaps[3].set_pixel(3, 5, lightGreen)
@green_leaf_bitmaps[3].set_pixel(4, 5, mint)
@green_leaf_bitmaps[3].set_pixel(5, 5, lightGreen)
@green_leaf_bitmaps[3].set_pixel(6, 5, khaki)
@green_leaf_bitmaps[3].set_pixel(7, 5, midGreen)
@green_leaf_bitmaps[3].fill_rect(2, 6, 2, 1, midGreen)
@green_leaf_bitmaps[3].set_pixel(4, 6, lightGreen)
@green_leaf_bitmaps[3].set_pixel(5, 6, khaki)
@green_leaf_bitmaps[3].set_pixel(6, 6, midGreen)

# 5ª parte del bimap de otro hoja
@green_leaf_bitmaps[4] = Bitmap.new(8, 8)
@green_leaf_bitmaps[4].set_pixel(6, 2, midGreen)
@green_leaf_bitmaps[4].set_pixel(7, 2, darkGreen)
@green_leaf_bitmaps[4].fill_rect(4, 3, 2, 1, midGreen)
@green_leaf_bitmaps[4].set_pixel(6, 3, khaki)
@green_leaf_bitmaps[4].set_pixel(2, 4, darkGreen)
@green_leaf_bitmaps[4].fill_rect(3, 4, 2, 1, khaki)
@green_leaf_bitmaps[4].set_pixel(5, 4, lightGreen)
@green_leaf_bitmaps[4].set_pixel(6, 4, khaki)
@green_leaf_bitmaps[4].set_pixel(1, 5, midGreen)
@green_leaf_bitmaps[4].set_pixel(2, 5, khaki)
@green_leaf_bitmaps[4].set_pixel(3, 5, lightGreen)
@green_leaf_bitmaps[4].set_pixel(4, 5, mint)
@green_leaf_bitmaps[4].set_pixel(5, 5, midGreen)
@green_leaf_bitmaps[4].set_pixel(2, 6, darkGreen)
@green_leaf_bitmaps[4].fill_rect(3, 6, 2, 1, midGreen)

# 6ª parte del bimap de otro hoja
@green_leaf_bitmaps[5] = Bitmap.new(8, 8)
@green_leaf_bitmaps[5].fill_rect(6, 2, 2, 1, midGreen)
@green_leaf_bitmaps[5].fill_rect(4, 3, 2, 1, midGreen)
@green_leaf_bitmaps[5].set_pixel(6, 3, khaki)
@green_leaf_bitmaps[5].set_pixel(3, 4, midGreen)
@green_leaf_bitmaps[5].set_pixel(4, 4, khaki)
@green_leaf_bitmaps[5].set_pixel(5, 4, lightGreen)
@green_leaf_bitmaps[5].set_pixel(6, 4, mint)
@green_leaf_bitmaps[5].set_pixel(1, 5, midGreen)
@green_leaf_bitmaps[5].set_pixel(2, 5, khaki)
@green_leaf_bitmaps[5].fill_rect(3, 5, 2, 1, mint)
@green_leaf_bitmaps[5].set_pixel(5, 5, lightGreen)
@green_leaf_bitmaps[5].set_pixel(2, 6, midGreen)
@green_leaf_bitmaps[5].set_pixel(3, 6, khaki)
@green_leaf_bitmaps[5].set_pixel(4, 6, lightGreen)

# 7ª parte del bimap de otro hoja
@green_leaf_bitmaps[6] = Bitmap.new(8, 8)
@green_leaf_bitmaps[6].fill_rect(6, 1, 1, 2, midGreen)
@green_leaf_bitmaps[6].fill_rect(4, 2, 2, 1, midGreen)
@green_leaf_bitmaps[6].fill_rect(6, 2, 1, 2, darkGreen)
@green_leaf_bitmaps[6].fill_rect(3, 3, 2, 1, midGreen)
@green_leaf_bitmaps[6].set_pixel(5, 3, khaki)
@green_leaf_bitmaps[6].set_pixel(2, 4, midGreen)
@green_leaf_bitmaps[6].set_pixel(3, 4, khaki)
@green_leaf_bitmaps[6].set_pixel(4, 4, lightGreen)
@green_leaf_bitmaps[6].set_pixel(5, 4, midGreen)
@green_leaf_bitmaps[6].set_pixel(1, 5, midGreen)
@green_leaf_bitmaps[6].set_pixel(2, 5, khaki)
@green_leaf_bitmaps[6].fill_rect(3, 5, 2, 1, midGreen)
@green_leaf_bitmaps[6].set_pixel(1, 6, darkGreen)
@green_leaf_bitmaps[6].set_pixel(2, 6, midGreen)

# 8ª parte del bimap de otro hoja
@green_leaf_bitmaps[7] = Bitmap.new(8, 8)
@green_leaf_bitmaps[7].set_pixel(6, 1, midGreen)
@green_leaf_bitmaps[7].fill_rect(4, 2, 3, 2, midGreen)
@green_leaf_bitmaps[7].set_pixel(3, 3, darkGreen)
@green_leaf_bitmaps[7].set_pixel(2, 4, darkGreen)
@green_leaf_bitmaps[7].set_pixel(3, 4, midGreen)
@green_leaf_bitmaps[7].fill_rect(4, 4, 2, 1, khaki)
@green_leaf_bitmaps[7].set_pixel(1, 5, darkGreen)
@green_leaf_bitmaps[7].set_pixel(2, 5, midGreen)
@green_leaf_bitmaps[7].fill_rect(3, 5, 2, 1, lightGreen)
@green_leaf_bitmaps[7].set_pixel(2, 6, midGreen)
@green_leaf_bitmaps[7].set_pixel(3, 6, lightGreen)

# 9ª parte del bimap de otro hoja
@green_leaf_bitmaps[8] = Bitmap.new(8, 8)
@green_leaf_bitmaps[8].fill_rect(6, 1, 1, 2, midGreen)
@green_leaf_bitmaps[8].fill_rect(4, 2, 2, 1, midGreen)
@green_leaf_bitmaps[8].fill_rect(6, 2, 1, 2, darkGreen)
@green_leaf_bitmaps[8].fill_rect(3, 3, 2, 1, midGreen)
@green_leaf_bitmaps[8].set_pixel(5, 3, khaki)
@green_leaf_bitmaps[8].set_pixel(2, 4, midGreen)
@green_leaf_bitmaps[8].set_pixel(3, 4, khaki)
@green_leaf_bitmaps[8].set_pixel(4, 4, lightGreen)
@green_leaf_bitmaps[8].set_pixel(5, 4, midGreen)
@green_leaf_bitmaps[8].set_pixel(1, 5, midGreen)
@green_leaf_bitmaps[8].set_pixel(2, 5, khaki)
@green_leaf_bitmaps[8].fill_rect(3, 5, 2, 1, midGreen)
@green_leaf_bitmaps[8].set_pixel(1, 6, darkGreen)
@green_leaf_bitmaps[8].set_pixel(2, 6, midGreen)

# 10ª parte del bimap de otro hoja
@green_leaf_bitmaps[9] = Bitmap.new(8, 8)
@green_leaf_bitmaps[9].fill_rect(6, 2, 2, 1, midGreen)
@green_leaf_bitmaps[9].fill_rect(4, 3, 2, 1, midGreen)
@green_leaf_bitmaps[9].set_pixel(6, 3, khaki)
@green_leaf_bitmaps[9].set_pixel(3, 4, midGreen)
@green_leaf_bitmaps[9].set_pixel(4, 4, khaki)
@green_leaf_bitmaps[9].set_pixel(5, 4, lightGreen)
@green_leaf_bitmaps[9].set_pixel(6, 4, mint)
@green_leaf_bitmaps[9].set_pixel(1, 5, midGreen)
@green_leaf_bitmaps[9].set_pixel(2, 5, khaki)
@green_leaf_bitmaps[9].fill_rect(3, 5, 2, 1, mint)
@green_leaf_bitmaps[9].set_pixel(5, 5, lightGreen)
@green_leaf_bitmaps[9].set_pixel(2, 6, midGreen)
@green_leaf_bitmaps[9].set_pixel(3, 6, khaki)
@green_leaf_bitmaps[9].set_pixel(4, 6, lightGreen)

# 11ª parte del bimap de otro hoja
@green_leaf_bitmaps[10] = Bitmap.new(8, 8)
@green_leaf_bitmaps[10].set_pixel(6, 2, midGreen)
@green_leaf_bitmaps[10].set_pixel(7, 2, darkGreen)
@green_leaf_bitmaps[10].fill_rect(4, 3, 2, 1, midGreen)
@green_leaf_bitmaps[10].set_pixel(6, 3, khaki)
@green_leaf_bitmaps[10].set_pixel(2, 4, darkGreen)
@green_leaf_bitmaps[10].fill_rect(3, 4, 2, 1, khaki)
@green_leaf_bitmaps[10].set_pixel(5, 4, lightGreen)
@green_leaf_bitmaps[10].set_pixel(6, 4, khaki)
@green_leaf_bitmaps[10].set_pixel(1, 5, midGreen)
@green_leaf_bitmaps[10].set_pixel(2, 5, khaki)
@green_leaf_bitmaps[10].set_pixel(3, 5, lightGreen)
@green_leaf_bitmaps[10].set_pixel(4, 5, mint)
@green_leaf_bitmaps[10].set_pixel(5, 5, midGreen)
@green_leaf_bitmaps[10].set_pixel(2, 6, darkGreen)
@green_leaf_bitmaps[10].fill_rect(3, 6, 2, 1, midGreen)



# 12ª parte del bimap de otro hoja
@green_leaf_bitmaps[11] = Bitmap.new(8, 8)
@green_leaf_bitmaps[11].fill_rect(0, 3, 1, 2, darkGreen)
@green_leaf_bitmaps[11].set_pixel(1, 4, midGreen)
@green_leaf_bitmaps[11].set_pixel(2, 4, khaki)
@green_leaf_bitmaps[11].set_pixel(3, 4, lightGreen)
@green_leaf_bitmaps[11].set_pixel(4, 4, darkGreen)
@green_leaf_bitmaps[11].set_pixel(7, 4, midGreen)
@green_leaf_bitmaps[11].set_pixel(1, 5, darkGreen)
@green_leaf_bitmaps[11].set_pixel(2, 5, midGreen)
@green_leaf_bitmaps[11].set_pixel(3, 5, lightGreen)
@green_leaf_bitmaps[11].set_pixel(4, 5, mint)
@green_leaf_bitmaps[11].set_pixel(5, 5, lightGreen)
@green_leaf_bitmaps[11].set_pixel(6, 5, khaki)
@green_leaf_bitmaps[11].set_pixel(7, 5, midGreen)
@green_leaf_bitmaps[11].fill_rect(2, 6, 2, 1, midGreen)
@green_leaf_bitmaps[11].set_pixel(4, 6, lightGreen)
@green_leaf_bitmaps[11].set_pixel(5, 6, khaki)
@green_leaf_bitmaps[11].set_pixel(6, 6, midGreen)

# 14ª parte del bimap de otro hoja
@green_leaf_bitmaps[12] = Bitmap.new(8, 8)
@green_leaf_bitmaps[12].set_pixel(1, 1, darkGreen)
@green_leaf_bitmaps[12].fill_rect(1, 2, 2, 1, midGreen)
@green_leaf_bitmaps[12].set_pixel(2, 3, midGreen)
@green_leaf_bitmaps[12].set_pixel(3, 3, darkGreen)
@green_leaf_bitmaps[12].set_pixel(4, 3, midGreen)
@green_leaf_bitmaps[12].fill_rect(2, 4, 2, 1, midGreen)
@green_leaf_bitmaps[12].set_pixel(4, 4, darkGreen)
@green_leaf_bitmaps[12].set_pixel(5, 4, lightGreen)
@green_leaf_bitmaps[12].set_pixel(3, 5, midGreen)
@green_leaf_bitmaps[12].set_pixel(4, 5, darkGreen)
@green_leaf_bitmaps[12].fill_rect(5, 5, 2, 1, khaki)
@green_leaf_bitmaps[12].fill_rect(4, 6, 2, 1, midGreen)
@green_leaf_bitmaps[12].set_pixel(6, 6, lightGreen)
@green_leaf_bitmaps[12].set_pixel(6, 7, khaki)

@rose_bitmaps = []
brightRed = Color.new(255, 0, 0, 255)
midRed = Color.new(179, 17, 17, 255)
darkRed = Color.new(141, 9, 9, 255)

# El 1º de los bipmap de los petalos de Rosa
@rose_bitmaps[0] = Bitmap.new(3, 3)
@rose_bitmaps[0].fill_rect(1, 0, 2, 1, brightRed)
@rose_bitmaps[0].fill_rect(0, 1, 1, 2, brightRed)
@rose_bitmaps[0].fill_rect(1, 1, 2, 2, midRed)
@rose_bitmaps[0].set_pixel(2, 2, darkRed)

# El 2º de los bipmap de los petalos de Rosa
@rose_bitmaps[1] = Bitmap.new(3, 3)
@rose_bitmaps[1].set_pixel(0, 1, midRed)
@rose_bitmaps[1].set_pixel(1, 1, brightRed)
@rose_bitmaps[1].fill_rect(1, 2, 1, 2, midRed)

@feather_bitmaps = []
white = Color.new(255, 255, 255, 255)

# El 3º de los bipmap de los petalos de Rosa
@feather_bitmaps[0] = Bitmap.new(3, 3)
@feather_bitmaps[0].set_pixel(0, 2, white)
@feather_bitmaps[0].set_pixel(1, 2, grey)
@feather_bitmaps[0].set_pixel(2, 1, grey)

# El 4º de los bipmap de los petalos de Rosa
@feather_bitmaps[0] = Bitmap.new(3, 3)
@feather_bitmaps[0].set_pixel(0, 0, white)
@feather_bitmaps[0].set_pixel(0, 1, grey)
@feather_bitmaps[0].set_pixel(1, 2, grey)

# El 5º de los bipmap de los petalos de Rosa
@feather_bitmaps[0] = Bitmap.new(3, 3)
@feather_bitmaps[0].set_pixel(2, 0, white)
@feather_bitmaps[0].set_pixel(1, 0, grey)
@feather_bitmaps[0].set_pixel(0, 1, grey)

# El 6º de los bipmap de los petalos de Rosa
@feather_bitmaps[0] = Bitmap.new(3, 3)
@feather_bitmaps[0].set_pixel(2, 2, white)
@feather_bitmaps[0].set_pixel(2, 1, grey)
@feather_bitmaps[0].set_pixel(1, 0, grey)

@blood_rain_bitmap = Bitmap.new(7, 56)
for i in 0..6
@blood_rain_bitmap.fill_rect(6-i, i*8, 1, 8, darkRed)
end

@sparkle_bitmaps = []

lightBlue = Color.new(181, 244, 255, 255)
midBlue = Color.new(126, 197, 235, 255)
darkBlue = Color.new(77, 136, 225, 255)

# Ahora continuamos con el bitmap de las chispas, este es el primero
@sparkle_bitmaps[0] = Bitmap.new(7, 7)
@sparkle_bitmaps[0].set_pixel(3, 3, darkBlue)

# 2º bitmap de Chispas
@sparkle_bitmaps[1] = Bitmap.new(7, 7)
@sparkle_bitmaps[1].fill_rect(3, 2, 1, 3, darkBlue)
@sparkle_bitmaps[1].fill_rect(2, 3, 3, 1, darkBlue)
@sparkle_bitmaps[1].set_pixel(3, 3, midBlue)

# 3º bitmap de Chispas
@sparkle_bitmaps[2] = Bitmap.new(7, 7)
@sparkle_bitmaps[2].set_pixel(3, 1, darkBlue)
@sparkle_bitmaps[2].set_pixel(5, 1, darkBlue)
@sparkle_bitmaps[2].set_pixel(2, 2, midBlue)
@sparkle_bitmaps[2].set_pixel(4, 2, midBlue)
@sparkle_bitmaps[2].set_pixel(3, 3, lightBlue)
@sparkle_bitmaps[2].set_pixel(2, 4, midBlue)
@sparkle_bitmaps[2].set_pixel(4, 4, midBlue)
@sparkle_bitmaps[2].set_pixel(1, 5, darkBlue)
@sparkle_bitmaps[2].set_pixel(5, 5, darkBlue)

# 4º bitmap de Chispas
@sparkle_bitmaps[3] = Bitmap.new(7, 7)
@sparkle_bitmaps[3].fill_rect(3, 1, 1, 5, darkBlue)
@sparkle_bitmaps[3].fill_rect(1, 3, 5, 1, darkBlue)
@sparkle_bitmaps[3].fill_rect(3, 2, 1, 3, midBlue)
@sparkle_bitmaps[3].fill_rect(2, 3, 3, 1, midBlue)
@sparkle_bitmaps[3].set_pixel(3, 3, lightBlue)

# 5º bitmap de Chispas
@sparkle_bitmaps[4] = Bitmap.new(7, 7)
@sparkle_bitmaps[4].fill_rect(2, 2, 3, 3, midBlue)
@sparkle_bitmaps[4].fill_rect(3, 2, 1, 3, darkBlue)
@sparkle_bitmaps[4].fill_rect(2, 3, 3, 1, darkBlue)
@sparkle_bitmaps[4].set_pixel(3, 3, lightBlue)
@sparkle_bitmaps[4].set_pixel(1, 1, darkBlue)
@sparkle_bitmaps[4].set_pixel(5, 1, darkBlue)
@sparkle_bitmaps[4].set_pixel(1, 5, darkBlue)
@sparkle_bitmaps[4].set_pixel(5, 1, darkBlue)

# 6º bitmap de Chispas
@sparkle_bitmaps[5] = Bitmap.new(7, 7)
@sparkle_bitmaps[5].fill_rect(2, 1, 3, 5, darkBlue)
@sparkle_bitmaps[5].fill_rect(1, 2, 5, 3, darkBlue)
@sparkle_bitmaps[5].fill_rect(2, 2, 3, 3, midBlue)
@sparkle_bitmaps[5].fill_rect(3, 1, 1, 5, midBlue)
@sparkle_bitmaps[5].fill_rect(1, 3, 5, 1, midBlue)
@sparkle_bitmaps[5].fill_rect(3, 2, 1, 3, lightBlue)
@sparkle_bitmaps[5].fill_rect(2, 3, 3, 1, lightBlue)
@sparkle_bitmaps[5].set_pixel(3, 3, white)

# 7º bitmap de Chispas
@sparkle_bitmaps[6] = Bitmap.new(7, 7)
@sparkle_bitmaps[6].fill_rect(2, 1, 3, 5, midBlue)
@sparkle_bitmaps[6].fill_rect(1, 2, 5, 3, midBlue)
@sparkle_bitmaps[6].fill_rect(3, 0, 1, 7, darkBlue)
@sparkle_bitmaps[6].fill_rect(0, 3, 7, 1, darkBlue)
@sparkle_bitmaps[6].fill_rect(2, 2, 3, 3, lightBlue)
@sparkle_bitmaps[6].fill_rect(3, 2, 1, 3, midBlue)
@sparkle_bitmaps[6].fill_rect(2, 3, 3, 1, midBlue)
@sparkle_bitmaps[6].set_pixel(3, 3, white)

@user_bitmaps = []
update_user_defined
end

def update_user_defined
for image in @user_bitmaps
image.dispose
end

#Bitmap de Definido por el Usurio
for name in $WEATHER_IMAGES
@user_bitmaps.push(RPG::Cache.picture(name))
end
for sprite in @sprites
sprite.bitmap = @user_bitmaps[rand(@user_bitmaps.size)]
end
end

attr_reader :type
attr_reader :max
attr_reader :ox
attr_reader :oy
end
end

-Creditos:
CCoa
PrincipeDragon
 
Mensajes
1.052
Reacciones
8
Puntos
0
Ubicación
Egipto, Tratando de detener a Dio
-Nombre Del Script:batalla lateral
-Version Del Script:no se
-Rpg Maker:XP

bueno la verdad esque ami este scrip no me va me dice que se a colgado al momento de provarlo pero se los dejo aver si a ustedes le va para que me ayuden selos dejo exactamento como lo encontre XD

Para empezar se deben crear dos nuevas clases

la primera llamada: Animated_sprite
que debe contener:

Este scrip:

[
Código:
#==============================================================================
# * Animated_Sprite                                Scripted by: RPG
#                                                  editado por: cybersam
#                                                traducido por: Dark_Buster_XYZ
#
# Quite el desmadre que no acupaba en mi script...
# lo demas es script de RPG... (aqui)
# 
#------------------------------------------------------------------------------
#  Una clase para Animated_sprite.
#==============================================================================

class Animated_Sprite < RPG::Sprite
  #--------------------------------------------------------------------------
  # - Variables de caso accesibles.
  #--------------------------------------------------------------------------
  attr_accessor :frames        # Numero de cuadrosdeanimacion 
  attr_accessor :delay         # tiempo entre cuadros (velocidad)
  attr_accessor :frame_width   # ancho de cadacuadro 
  attr_accessor :frame_height  # alto de cada cuadro
  attr_accessor :offset_x      # Coordenada X para el primer cuadro
  attr_accessor :offset_y      # Coordenada Y para todos los cuadros
  attr_accessor :current_frame # cuadro de animacion actual
  attr_accessor :moving        # se esta moviendo el sprite?

  #--------------------------------------------------------------------------
  # - Analiza un sprite animado
  #   puerto de vista : puerto de vista del sprite
  #--------------------------------------------------------------------------
  def initialize(viewport = nil)
    super(viewport)
    @frame_width, @frame_height = 0, 0
    change    # un cambio basico para iniciar variables
    @old = Graphics.frame_count  # parael metodo de retarzo
    @goingup = true    # Incrementando animacion? (if @rm2k_mode is true)
    @once = false      # la animacion solo se reproduce una vez?
    @animated = true   # suele parar la animacion si @once es true
  end

  #--------------------------------------------------------------------------
  # Comentario por RPG
  #   - Cambia la fuente (cambia la animacion)
  #   frames : Numero de cuadros
  #   delay : retarzo del cuadro, controla la velocidad
  #   offx : Coordenada X para el cuadro inicial
  #   offy : Coordenada y para todos los cuadros
  #   startf : Cuadro en que inicialaanimacion
  #   once : la animacion se reproduce una vez?
  #   rm2k_mode : modelo de animacion: 1-2-3-2 si es true, 1-2-3-1 si es false
  #
  # Comentario por cybersam
  #
  # el rm2k_mode ya no esta...
  #--------------------------------------------------------------------------
  def change(frames = 0, delay = 0, offx = 0, offy = 0,
             startf = 0, once = false)
    @frames = frames
    @delay = delay
    @offset_x, @offset_y = offx, offy
    @current_frame = startf
    @once = once
    x = @current_frame * @frame_width + @offset_x
    self.src_rect = Rect.new(x, @offset_y, @frame_width, @frame_height)
    @goingup = true
    @animated = true
  end
  
  #--------------------------------------------------------------------------
  # - Actualizar animacion y movimiento
  #--------------------------------------------------------------------------
  def update
    super
    if self.bitmap != nil and delay(@delay) and @animated
      x = @current_frame * @frame_width + @offset_x
      self.src_rect = Rect.new(x, @offset_y, @frame_width, @frame_height)
        @current_frame = (@current_frame + 1) unless @frames == 0
        @animated = false if @current_frame == @frames and @once
        @current_frame %= @frames
    end
  end
  
  #--------------------------------------------------------------------------
  # - Move el sprite
  #   x : Coordenada X para el punto de destino
  #   y : Coordenada Y para el punto de destinot
  #   speed : velocidad de animacion (0 = retrazado, 1+ = rapido)
  #   delay : movimiento retrazado si la velocidad es = 0
  #--------------------------------------------------------------------------
  def move(x, y, speed = 1, delay = 0)
    @destx = x
    @desty = y
    @move_speed = speed
    @move_delay = delay
    @move_old = Graphics.frame_count
    @moving = true
  end
  
  #--------------------------------------------------------------------------
  # - Mueve el sprite a destx y desty
  #--------------------------------------------------------------------------
  def update_move
    return unless @moving
    movinc = @move_speed == 0 ? 1 : @move_speed
    if Graphics.frame_count - @move_old > @move_delay or @move_speed != 0
      self.x += movinc if self.x < @destx
      self.x -= movinc if self.x > @destx
      self.y += movinc if self.y < @desty
      self.y -= movinc if self.y > @desty
      @move_old = Graphics.frame_count
    end
    if @move_speed > 1  # Checasi el Sprite no pude llegar a su destino
      self.x = @destx if (@destx - self.x).abs % @move_speed != 0 and
                         (@destx - self.x).abs <= @move_speed
      self.y = @desty if (@desty - self.y).abs % @move_speed != 0 and
                         (@desty - self.y).abs <= @move_speed
    end
    if self.x == @destx and self.y == @desty
      @moving = false
    end
  end
  
  #--------------------------------------------------------------------------
  # - Pausa la animacion, pero lo sigue actualizando
  #   frames : numero de cuadros
  #--------------------------------------------------------------------------
  def delay(frames)
    update_move
    if (Graphics.frame_count - @old >= frames)
      @old = Graphics.frame_count
      return true
    end
    return false
  end
end

y debajo de esta la segunda llamada: Battle_animation
quer debe contener

Este otro scrip:

Código:
#===============================================================================
#
#   Full Animated Side View Battle System (CBS) (v2.5)               by cybersam
#
#===============================================================================
#
# y arrancamos!!!...
# esto hace el script muy fácil de ejecutar 
# solamente añaden una nueva clase sobre "Main" 
# e insertan esta cosa rara ahi
#
# como pueden ver que el scrip de cambio de sprite es del script 
# japones entonces los créditos van para ellos ....
# lo edite un poco para que mostrara mas sprites y animaciones 
# y añadi unaque otra cosita ... 
# las siguiente es el movimiento de jugador...
#
#
#
# conseguí el script cambi battler en el scrip japones...
# los créditos de esto van al tipo que hizo esto...
# 
#  XRXS11.  ver.0 
# 
# desde este instante no mas scrip japones ... 
# no mas credito a ellos...
# pero le dejaré aquí ya que esto me ayudó mucho...
# 
# 
# como para las ideas ... missy me dio ideas realmente buenas 
# que me ayudaron un chorro cuando no hallaba el rollo a algunos de estos rasgos...
#
# un credito mas que mencionar...
# es un scriptde RPG...
# no todo aqui... 
# pero lo veras en los comentarios de script
#
#-------------------------------------------------------------------------------
#
# ok... desde que uso el movement script de RPG...
# hubo muchos cambios... 
# 
# cuando mires el script encontraras lineascomo: "pose(n)" o "enemy_pose(n)"
# desdeque quize que mis sprites tuvieran diferentes sprites... 
# agregue una opcion a esto...
# si escribe un numero despues de "n" (la "n" significa el sprite que se 
# esta usando)
# fo example 8... ("pose(4, 8)") esto le dira al escrip quela animacion 4 
# tiene 8 cuadros...
# pose se usa con el juagador... y enemy_pose para el enemigo...
# use mis viejos numeros de sprite... (esta vezen solo un sprite...)
#
# esplicacion de las animaciones... (los digitos)
#
#
# 0 = mover (durante la pelea)
# 1 = inmovil
# 2 = defenza
# 3 = golpe (ser atacado)
# 4 = ataque
# 5 = habilidad
# 6 = muerte
# 7 = pose de victoria... idea de RPG....
# 
#
# por su puesto este solo es el comienzo... 
# se pueden agragar masanimaciones...
# pero por ahora es suficiente...
# 
# mucho se cambio... y parece que ya quedo...
# por supuesto nesesita ser refinado porti para que se adecue a tu juego...
#
#
#-------------------------------------------------------------------------------



class Game_Actor < Game_Battler
  
# no nesitas cambiar al actordel juego para que funcione
# en la batalla...
# esto lo hace por ti... ^-^

  def screen_x
    if self.index != nil
      return self.index * 40 + 460
    else
      return 0
    end
  end

  def screen_y
    return self.index * 20 + 220
  end
  
  def screen_z
    if self.index != nil
      return self.index
    else
      return 0
    end
  end
end


class Spriteset_Battle
  #desmadre de RPG...
  attr_accessor :actor_sprites
  attr_accessor :enemy_sprites
  # acaba aqui... ^-^
  
  def initialize
    @viewport0 = Viewport.new(0, 0, 640, 480)
    @viewport1 = Viewport.new(0, 0, 640, 480)
    @viewport2 = Viewport.new(0, 0, 640, 480)
    @viewport3 = Viewport.new(0, 0, 640, 480)
    @viewport4 = Viewport.new(0, 0, 640, 480)
    @viewport2.z = 101
    @viewport3.z = 200
    @viewport4.z = 5000

    @battleback_sprite = Sprite.new(@viewport0)
    # arreglo para enemigos... para que no ataquen al incorrecto...
    # lo arregle hace mucho pero de todos modos lo comento 
    # pa que sepan de eso... ^-^''
    @enemy_sprites = []
    for enemy in $game_troop.enemies#.reverse
      @enemy_sprites.push(Sprite_Battler.new(@viewport1, enemy))
    end
    
    @actor_sprites = []
    @actor_sprites.push(Sprite_Battler.new(@viewport2))
    @actor_sprites.push(Sprite_Battler.new(@viewport2))
    @actor_sprites.push(Sprite_Battler.new(@viewport2))
    @actor_sprites.push(Sprite_Battler.new(@viewport2))
    
    @weather = RPG::Weather.new(@viewport0)
    @picture_sprites = []
    for i in 51..100
      @picture_sprites.push(Sprite_Picture.new(@viewport3,
        $game_screen.pictures[i]))
    end
    @timer_sprite = Sprite_Timer.new
    update
  end
  
  
  def dispose
    if @battleback_sprite.bitmap != nil
      @battleback_sprite.bitmap.dispose
    end
    @battleback_sprite.dispose
    for sprite in @enemy_sprites + @actor_sprites
      sprite.dispose
    end
    @weather.dispose
    for sprite in @picture_sprites
      sprite.dispose
    end
    @timer_sprite.dispose
    @viewport0.dispose
    @viewport1.dispose
    @viewport2.dispose
    @viewport3.dispose
    @viewport4.dispose
  end
  
  def update
    # esto hace que el personaje active tenga prioridad... (por Missy)
    @viewport1.z = 50 and @viewport2.z = 51 if $actor_on_top == true
    @viewport1.z = 51 and @viewport2.z = 50 if $actor_on_top == false
    
    @actor_sprites[0].battler = $game_party.actors[0]
    @actor_sprites[1].battler = $game_party.actors[1]
    @actor_sprites[2].battler = $game_party.actors[2]
    @actor_sprites[3].battler = $game_party.actors[3]
    
    if @battleback_name != $game_temp.battleback_name
      @battleback_name = $game_temp.battleback_name
      if @battleback_sprite.bitmap != nil
        @battleback_sprite.bitmap.dispose
      end
      @battleback_sprite.bitmap = RPG::Cache.battleback(@battleback_name)
      @battleback_sprite.src_rect.set(0, 0, 640, 480)
      if @battleback_sprite.bitmap.height == 320
        @battleback_sprite.zoom_x = 1.5
        @battleback_sprite.zoom_y = 1.5
        @battleback_sprite.x = 320
        @battleback_sprite.y = 480
        @battleback_sprite.ox = @battleback_sprite.bitmap.width / 2
        @battleback_sprite.oy = @battleback_sprite.bitmap.height
      else
        @battleback_sprite.x = 0
        @battleback_sprite.y = 0
        @battleback_sprite.ox = 0
        @battleback_sprite.oy = 0
        @battleback_sprite.zoom_x = 1
        @battleback_sprite.zoom_y = 1
      end
    end
    
    for sprite in @enemy_sprites + @actor_sprites
      sprite.update
    end
    
    @weather.type = $game_screen.weather_type
    @weather.max = $game_screen.weather_max
    @weather.update
    
    for sprite in @picture_sprites
      sprite.update
    end
    
    @timer_sprite.update
    
    @viewport0.tone = $game_screen.tone
    @viewport0.ox = $game_screen.shake
    
    @viewport4.color = $game_screen.flash_color
    
    @viewport0.update
    @viewport1.update
    @viewport2.update
    @viewport4.update
  end
end

#==============================================================================
# Sprite Battler para el sistema de batalla lateral
#==============================================================================
# aqui haces animaciones y esas cosas...
# se que no es la mejor manera...
# pero fue la primera funcional que encontre....
# estonesestia cierto conocimiento de como funcionana las animaciones...
# si deseas cambiar algo...
# no lo explicare mucho por que es facil si sabes que hacer
# por otro lado creo quete tomara un pococ entenderlo, pero creo que quien 
# de editar esto sabe queesta haciendo... ^-^
#
#
# 
# aqui cambiare totalmente la clase "Sprite_Battler"...
# por lo que si cambiaste algo ahi tambien lo debes cambiar aqui
# (creo... que no lo probe... asi que te lo dejo a tu criterio)
# lo agregue lo marcare con: --> #
# lo que se tieneque explicar viene comentado...
# pero no completamente...


class Sprite_Battler < Animated_Sprite

  attr_accessor :battler
  attr_reader   :index
  attr_accessor :target_index
  attr_accessor :frame_width

  
  def initialize(viewport, battler = nil)
    super(viewport)
    @battler = battler
    @pattern_b = 0 #
    @counter_b = 0 #
    @index = 0     #
    
    # esto es parael estado de la animacion...
    # nolocambies amenosque sepas lo que haces...
    $noanimation = false
    
    @frame_width, @frame_height = 64, 64
    # esmpieza el sprite
    @battler.is_a?(Game_Enemy) ? enemy_pose(1) : pose(1)
    
    @battler_visible = false
    if $target_index == nil
      $target_index = 0
    end
  end
  
  def index=(index) #
    @index = index  # 
    update          # 
  end               # 
  
  def dispose
    if self.bitmap != nil
      self.bitmap.dispose
    end
    super
  end
  
  def enemy                                             #
    $target_index += $game_troop.enemies.size
    $target_index %= $game_troop.enemies.size
    return $game_troop.enemies[$target_index]           #
  end                                                   #
  
  def actor                                             #
    $target_index += $game_party.actors.size
    $target_index %= $game_party.actors.size
    return $game_party.actors[$target_index]            #
  end           

#==============================================================================
# aqui hay un fragmento del scriptde RPG...
# solo cambie lineas desde aqui...
#
# aqui pudes agregar mas lineasde animacion... si tienes... ^-^
#==============================================================================
  def pose(number, frames = 4)
    case number
    when 0  # correr
      change(frames, 5, 0, 0, 0)
    when 1  # inmovil
      change(frames, 5, 0, @frame_height)
    when 2 # defender
      change(frames, 5, 0, @frame_height * 2)
    when 3 # herido
      change(frames, 5, 0, @frame_height * 3)
    when 4 # ataque
      change(frames, 5, 0, @frame_height * 4, 0, true)
    when 5 # habilidad
      change(frames, 5, 0, @frame_height * 5)
    when 6 # muerte
      change(frames, 5, 0, @frame_height * 6)
    when 7 # victoria
      change(frames, 5, 0, @frame_height * 7)
    #when 8
    # change(frames, 5, 0, @frame_height * 9)
    # ...etc.
    else
      change(frames, 5, 0, 0, 0)
    end
  end
  
  #--------------------------------------------------------------------------
  # - Cambia la pose del enemigo
  #   numero : numero de la pose
  #--------------------------------------------------------------------------
  def enemy_pose(number ,enemy_frames = 4)
    case number
    when 0  # correr
      change(enemy_frames, 5, 0, 0, 0)
    when 1  # inmovil
      change(enemy_frames, 5, 0, @frame_height)
    when 2 # defender
      change(enemy_frames, 5, 0, @frame_height * 2)
    when 3 # herido
      change(enemy_frames, 5, 0, @frame_height * 3)
    when 4 # ataque
      change(enemy_frames, 5, 0, @frame_height * 4, 0, true)
    when 5 # habilidad
      change(enemy_frames, 5, 0, @frame_height * 5)
    when 6 # muerte
      change(enemy_frames, 5, 0, @frame_height * 6)
    when 7 # victoria
      change(enemy_frames, 5, 0, @frame_height * 7)
    # ...etc.
    else
      change(enemy_frames, 5, 0, 0, 0)
    end
  end
  
  def default_pose
    pose(1)
    
    # aqui se cambia la pose de default si 
    # no tenemos mas del 75% de vida
    
    # si PV es un poco bajo (- 25%)
    if (@battler.hp * 100) /@battler.maxhp  < 25
      pose(9)
    # si PV es bajo (- 50%)
    elsif (@battler.hp * 100) /@battler.maxhp  < 50
      pose(9)
    # si pv es muy bajo (- 75%)
    elsif (@battler.hp * 100) /@battler.maxhp  < 75
      pose(9)
    end
    
    
    # y aqui cambiamos la animacion siel personaje esta
    # envenenado, dormido, o similar...
    # solo puse el dormido y el envenenado para provar...
    if @battler.state?(3) # veneno
      # cambia a la pose de dormido... 
      # (notengo muchos sprites asi que use la de defenza)
      # puedes agregar mas sprites, incluse uno para cada estado...
      pose(2)
    elsif @battler.state?(7) #dormido
      # cambia a envene nado
      pose(6)
    end
  end
#==============================================================================
# fin del fracmento...
#==============================================================================  
  
  
  def update
    super
    
    if @battler == nil                                                      
      self.bitmap = nil                                                     
      loop_animation(nil)                                                   
      return                                                                
    end
    
    if @battler.name != @battler_name
       @battler.battler_hue != @battler_hue

      @battler_hue = @battler.battler_hue
      @battler_name = @battler.name
      self.bitmap = RPG::Cache.battler(@battler_name, @battler_hue)
      @width = bitmap.width
      @height = bitmap.height
      self.ox = @frame_width / 2
      self.oy = @frame_height

      if @battler.dead? or @battler.hidden
        self.opacity = 0
      end
      self.x = @battler.screen_x
      self.y = @battler.screen_y
      self.z = @battler.screen_z
    end
    
    if $noanimation == false
      if @battler.damage == nil and
         @battler.state_animation_id != @state_animation_id
        @state_animation_id = @battler.state_animation_id
        loop_animation($data_animations[@state_animation_id])
      end
    else
      dispose_loop_animation
    end
    

    if @battler.is_a?(Game_Actor) and @battler_visible
      if $game_temp.battle_main_phase
        self.opacity += 3 if self.opacity < 255
      else
        self.opacity -= 3 if self.opacity > 207
      end
    end

    if @battler.blink
      blink_on
    else
      blink_off
    end

    unless @battler_visible
      if not @battler.hidden and not @battler.dead? and
         (@battler.damage == nil or @battler.damage_pop)
        appear
        @battler_visible = true
      end
      if not @battler.hidden and
         (@battler.damage == nil or @battler.damage_pop) and
         @battler.is_a?(Game_Actor)
        appear
        @battler_visible = true
      end
    end
    if @battler_visible
      if @battler.hidden
        $game_system.se_play($data_system.escape_se)
        escape
        @battler_visible = false
      end
      if @battler.white_flash
        whiten
        @battler.white_flash = false
      end
      if @battler.animation_id != 0
        animation = $data_animations[@battler.animation_id]
        animation(animation, @battler.animation_hit)
        @battler.animation_id = 0
      end
      if @battler.damage_pop
        damage(@battler.damage, @battler.critical)
        @battler.damage = nil
        @battler.critical = false
        @battler.damage_pop = false
      end
      if @battler.damage == nil and @battler.dead?
        if @battler.is_a?(Game_Enemy)
          $game_system.se_play($data_system.enemy_collapse_se)
          collapse
          @battler_visible = false
        else
          $game_system.se_play($data_system.actor_collapse_se) unless @dead
          @dead = true
          pose(6)
        end
      else
        @dead = false
      end
    end                                                                #
  end
end


#==============================================================================
# Scene_Battle Sistemade Batalla Lateral
#==============================================================================

class Scene_Battle
  
  
  def update_phase4
    case @phase4_step
    when 1
      update_phase4_step1
    when 2
      update_phase4_step2
    when 3
      update_phase4_step3
    when 4
      update_phase4_step4
    when 5
      update_phase4_step5
    when 6
      update_phase4_step6
    when 7
      update_phase4_step7
    end
  end
  
  
  def update_phase4_step1

    # Cambiala pose del actor a default
    #if @active_battler.is_a?(Game_Actor)
    #  @spriteset.actor_sprites[@active_battler.index].default_pose
    #end
    for i in 0...$game_party.actors.size
      actor = $game_party.actors[i]
      @spriteset.actor_sprites[i].default_pose unless actor.dead?
    end

    @help_window.visible = false
    if judge
      return
    end
    if $game_temp.forcing_battler == nil
      setup_battle_event
      if $game_system.battle_interpreter.running?
        return
      end
    end
    if $game_temp.forcing_battler != nil
      @action_battlers.delete($game_temp.forcing_battler)
      @action_battlers.unshift($game_temp.forcing_battler)
    end
    if @action_battlers.size == 0
      start_phase2
      return
    end
    @animation1_id = 0
    @animation2_id = 0
    @common_event_id = 0
    @active_battler = @action_battlers.shift
    if @active_battler.index == nil
      return
    end
    if @active_battler.hp > 0 and @active_battler.slip_damage?
      @active_battler.slip_damage_effect
      @active_battler.damage_pop = true
    end
    @active_battler.remove_states_auto
    @status_window.refresh
    @phase4_step = 2
  end
  
  
  def make_basic_action_result
    
    if @active_battler.is_a?(Game_Actor)
      $actor_on_top = true
    elsif @active_battler.is_a?(Game_Enemy)
      $actor_on_top = false
    end
    
    if @active_battler.current_action.basic == 0
#============================================================================
# EMPIEZAN LAS ARMAS...
#============================================================================
# 
#======== DIFERENTES ARMAS CON DIFERENTES ANIMACIONES
#
# es massimple de lo que parece...
# si quiresagregar una animacion a un arma checa...
# y espero que descubras como funciona...
#
#
# si no...
# aqui esta como...
# primero... 
# solo copia y pega "elseif @active_battler_enemy.weapon_id == ID..." 
# justo después el último @weapon_sprite....
# 
# El ID lo nesesitas chacaren tu base de datos y ver el numero antes de tu arma 
# y ese el Id que nesesitas...
#
# lo mismova para el lado enemigo... ^-^
# normalmento los enemigosno acupan mas sprites para armas....
#
# si quieres usar mas... esntonces reemplaza "@weapon_sprite_enemy = 4"
# con estas lineas... (pero ocupas editarlas)
#
#        if @active_battler.weapon_id == 1 # <--  numero ID del arma
#          @weapon_sprite_enemy = 4 # <-- animacion de batalla
#        elsif @active_battler.weapon_id == 5 # <-- numero ID del arma
#          @weapon_sprite_enemy = 2 # <-- animacion de batalla
#        elsif @active_battler.weapon_id == 9 # <-- numero ID del arma
#          @weapon_sprite_enemy = 0 # <-- animacion de batalla
#        elsif @active_battler.weapon_id == 13 # <-- numero ID del arma
#          @weapon_sprite_enemy = 6 # <-- animacion de batalla
#        else
#          @weapon_sprite_enemy = 4
#        end
# 
#================================= FIN

      if @active_battler.is_a?(Game_Actor)
        if @active_battler.weapon_id == 1 # <--  numero ID del arma
          @weapon_sprite = 4 # <-- animacion de batalla
        elsif @active_battler.weapon_id == 5 # <-- numero ID del arma
          @weapon_sprite = 2 # <-- animacion de batalla
        elsif @active_battler.weapon_id == 9 # <-- numero ID del arma
          @weapon_sprite = 0 # <-- animacion de batalla
        elsif @active_battler.weapon_id == 13 # <-- numero ID del arma
          @weapon_sprite = 6 # <-- animacion de batalla
        else
          @weapon_sprite = 4
        end
        
# seccion del enemigo aqui... ^-^

      else# @active_battler.is_a?(Game_Enemy)
          @weapon_sprite_enemy = 4
      end
        
#
#=============================================================================
# Fin de las armas....
#=============================================================================
      
      
      @animation1_id = @active_battler.animation1_id
      @animation2_id = @active_battler.animation2_id
      if @active_battler.is_a?(Game_Enemy)
        if @active_battler.restriction == 3
          target = $game_troop.random_target_enemy
        elsif @active_battler.restriction == 2
          target = $game_party.random_target_actor
        else
          index = @active_battler.current_action.target_index
          target = $game_party.smooth_target_actor(index)
        end
#======== aqui se configuran movimientos y animaciones...
          x = target.screen_x - 32
          @spriteset.enemy_sprites[@active_battler.index].enemy_pose(0)
          @spriteset.enemy_sprites[@active_battler.index]\
          .move(x, target.screen_y, 10)
#========= si abserbas la configuracion del script RPG
#========= que el toma el numero 40 para la velocidad de la animacion... 
#========= y creoque es muy rapidoasi que lo baje a 10...
      end
      if @active_battler.is_a?(Game_Actor)
        if @active_battler.restriction == 3
          target = $game_party.random_target_actor
        elsif @active_battler.restriction == 2
          target = $game_troop.random_target_enemy
        else
          index = @active_battler.current_action.target_index
          target = $game_troop.smooth_target_enemy(index)
        end
#======= lo mismo para el jugador... ^-^
        x = target.screen_x + 32
        @spriteset.actor_sprites[@active_battler.index].pose(0)
        @spriteset.actor_sprites[@active_battler.index]\
        .move(x, target.screen_y, 10)
      end
      @target_battlers = [target]
      for target in @target_battlers
        target.attack_effect(@active_battler)
      end
      return
    end
    if @active_battler.current_action.basic == 1
      if @active_battler.is_a?(Game_Actor)
        @spriteset.actor_sprites[@active_battler.index].pose(2) #defenza
      else
        @spriteset.enemy_sprites[@active_battler.index].enemy_pose(2) #defenza
      end
      @help_window.set_text($data_system.words.guard, 1)
      return
    end
    if @active_battler.is_a?(Game_Enemy) and
       @active_battler.current_action.basic == 2
      @help_window.set_text("Escapar", 1)
      @active_battler.escape
      return
    end
    if @active_battler.current_action.basic == 3
      $game_temp.forcing_battler = nil
      @phase4_step = 1
      return
    end
    
    if @active_battler.current_action.basic == 4
      if $game_temp.battle_can_escape == false
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      $game_system.se_play($data_system.decision_se)
      update_phase2_escape
      return
    end
  end
  #--------------------------------------------------------------------------
  # Accion de Habilidad...
  #--------------------------------------------------------------------------
  def make_skill_action_result
    
    @skill = $data_skills[@active_battler.current_action.skill_id]
    unless @active_battler.current_action.forcing
      unless @active_battler.skill_can_use?(@skill.id)
        $game_temp.forcing_battler = nil
        @phase4_step = 1
        return
      end
    end
    @active_battler.sp -= @skill.sp_cost
    @status_window.refresh
    @help_window.set_text(@skill.name, 1)
    
#=============================================================================
# INICIAN LOS SPRITESDE HABILIDAD
#=============================================================================
# es lo mismo que en el de armas...
#============================================================================
# Animacion de batalla Battle_animation
#============================================================================
#
# para quien esta en esto por primera vez
# vean el script espero que sea facil deentender...
# 
# el numero despues de "pose" es el IDde animacion... y es igual para las demas.
# si tienes una animacion de habilidad con mascuadros... 
# solo insertael numaro de cuadros despues del primer numero...
# se ve asi.... "pose(5, 8)" <-- 5 es la animacion... 
# 8 esel maximo de cuadros (quiere decir que tu animacion tiene 8 cuadros...) ^-^
    
    if @active_battler.is_a?(Game_Actor)
      if @skill.name == "Cura" # <-- nombre de la primer habilidad
        @spriteset.actor_sprites[@active_battler.index].pose(5) # <-- numero del sprite
      elsif @skill.name == "Cross Cut" # <-- nombre de la segunda habilidad
        @spriteset.actor_sprites[@active_battler.index].pose(6) # <-- numero del sprite
      elsif @skill.name == "Fuego" # <-- nombre de la tercer habilidad
        @spriteset.actor_sprites[@active_battler.index].pose(6) # <-- numero del sprite
      end
    else
      if @skill.name == "Cura" # <-- nombre de la primer habilidad
        @spriteset.enemy_sprites[@active_battler.index].enemy_pose(5) # <-- numero del sprite
      elsif @skill.name == "Cross Cut" # <-- nombre de la segunda habilidad
        @spriteset.enemy_sprites[@active_battler.index].enemy_pose(6) # <-- numero del sprite
      elsif @skill.name == "Fuego" # <-- nombre de la tercer habilidad
        @spriteset.enemy_sprites[@active_battler.index].enemy_pose(6) # <-- numero del sprite
      end
    end
#=============================================================================
# TERMINAN LAS HABILIDADES
#=============================================================================
    
    @animation1_id = @skill.animation1_id
    @animation2_id = @skill.animation2_id
    @common_event_id = @skill.common_event_id
    set_target_battlers(@skill.scope)
    for target in @target_battlers
      target.skill_effect(@active_battler, @skill)
    end
  end
  #--------------------------------------------------------------------------
  # Como usamos los items
  #--------------------------------------------------------------------------
  def make_item_action_result
   
    # disculpen pero aqui no meti mano...
    # por quenotengo sprite de uso de objetos....
    # soloagregue el sprite "inmovil" aqui...
    # cuando tenga mastiempo usare uno... ^-^
    # es lo mismo que en los otros...
    if @active_battler.is_a?(Game_Actor)
      @spriteset.actor_sprites[@active_battler.index].pose(1)
    else
      @spriteset.enemy_sprites[@active_battler.index].enemy_pose(1)
    end
    
    @item = $data_items[@active_battler.current_action.item_id]
    unless $game_party.item_can_use?(@item.id)
      @phase4_step = 1
      return
    end
    if @item.consumable
      $game_party.lose_item(@item.id, 1)
    end
    @help_window.set_text(@item.name, 1)
    @animation1_id = @item.animation1_id
    @animation2_id = @item.animation2_id
    @common_event_id = @item.common_event_id
    index = @active_battler.current_action.target_index
    target = $game_party.smooth_target_actor(index)
    set_target_battlers(@item.scope)
    for target in @target_battlers
      target.item_effect(@item)
    end
  end
  
#==============================================================================
# otra vez.... un fracmento del scriptde RPG
#==============================================================================


# esto es parala pose de victoria...

  def start_phase5
    @phase = 5
    $game_system.me_play($game_system.battle_end_me)
    $game_system.bgm_play($game_temp.map_bgm)
    exp = 0
    gold = 0
    treasures = []
    for enemy in $game_troop.enemies
      unless enemy.hidden
        exp += enemy.exp
        gold += enemy.gold
        if rand(100) < enemy.treasure_prob
          if enemy.item_id > 0
            treasures.push($data_items[enemy.item_id])
          end
          if enemy.weapon_id > 0
            treasures.push($data_weapons[enemy.weapon_id])
          end
          if enemy.armor_id > 0
            treasures.push($data_armors[enemy.armor_id])
          end
        end
      end
    end
    treasures = treasures[0..5]
    for i in 0...$game_party.actors.size
      actor = $game_party.actors[i]
      $noanimation = true
      @spriteset.actor_sprites[i].pose(7) unless actor.dead? # {=====}
      if actor.cant_get_exp? == false
        last_level = actor.level
        actor.exp += exp
        if actor.level > last_level
          @status_window.level_up(i)
        end
      end
    end
    $game_party.gain_gold(gold)
    for item in treasures
      case item
      when RPG::Item
        $game_party.gain_item(item.id, 1)
      when RPG::Weapon
        $game_party.gain_weapon(item.id, 1)
      when RPG::Armor
        $game_party.gain_armor(item.id, 1)
      end
    end
    @result_window = Window_BattleResult.new(exp, gold, treasures)
    @phase5_wait_count = 100
  end
  
  #--------------------------------------------------------------------------
  # actualizando el movimiento
  # desde queRPG nolo comentaba... yo lo explicare...
  #--------------------------------------------------------------------------
  def update_phase4_step3
    if @active_battler.current_action.kind == 0 and
       @active_battler.current_action.basic == 0
       # aqui... tenemos la animaciones de armas... para jugadores y enemigos
      if @active_battler.is_a?(Game_Actor)
        @spriteset.actor_sprites[@active_battler.index].pose(@weapon_sprite)
      elsif @active_battler.is_a?(Game_Enemy)
        @spriteset.enemy_sprites[@active_battler.index].enemy_pose(@weapon_sprite_enemy)
      end
    end
    if @animation1_id == 0
      @active_battler.white_flash = true
    else
      @active_battler.animation_id = @animation1_id
      @active_battler.animation_hit = true
    end
    @phase4_step = 4
  end

  def update_phase4_step4
    # aqui para la animacion del golpe...
    for target in @target_battlers
      if target.is_a?(Game_Actor) and !@active_battler.is_a?(Game_Actor)
        if target.guarding?
          @spriteset.actor_sprites[target.index].pose(2)
        else
          @spriteset.actor_sprites[target.index].pose(3)
        end
        elsif target.is_a?(Game_Enemy) and !@active_battler.is_a?(Game_Enemy)
        if target.guarding?
          @spriteset.enemy_sprites[target.index].enemy_pose(2)
        else
          @spriteset.enemy_sprites[target.index].enemy_pose(3)
        end
      end
      target.animation_id = @animation2_id
      target.animation_hit = (target.damage != "Miss")
    end
    @wait_count = 8
    @phase4_step = 5
  end

  def update_phase4_step5
    if @active_battler.hp > 0 and @active_battler.slip_damage?
      @active_battler.slip_damage_effect
      @active_battler.damage_pop = true
    end

    @help_window.visible = false
    @status_window.refresh

    if @active_battler.is_a?(Game_Actor)
      @spriteset.actor_sprites[@active_battler.index].pose(1)
    else
      @spriteset.enemy_sprites[@active_battler.index].enemy_pose(1)
    end
    for target in @target_battlers
      if target.damage != nil
        target.damage_pop = true
        if @active_battler.is_a?(Game_Actor)
          @spriteset.actor_sprites[@active_battler.index].pose(1)
        else
          @spriteset.enemy_sprites[@active_battler.index].enemy_pose(1)
        end
      end
    end
    @phase4_step = 6
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新 (メインフェーズ ステップ 6 : リフレッシュ)
  #--------------------------------------------------------------------------
  def update_phase4_step6
    
    # aqui vemos si el jugador esta muerto y si es jugador o ememigo...
    # estas lineas son para correrde regreso y la animacion inmovil....
    if @active_battler.is_a?(Game_Actor) and !@active_battler.dead?
      @spriteset.actor_sprites[@active_battler.index]\
      .move(@active_battler.screen_x, @active_battler.screen_y, 20)
      @spriteset.actor_sprites[@active_battler.index].pose(0)
    elsif !@active_battler.dead?
      @spriteset.enemy_sprites[@active_battler.index]\
      .move(@active_battler.screen_x, @active_battler.screen_y, 20)
      @spriteset.enemy_sprites[@active_battler.index].enemy_pose(0)
    end
    for target in @target_battlers
      if target.is_a?(Game_Actor) and !target.dead?
          @spriteset.actor_sprites[target.index].pose(1)
        elsif !target.dead?
          @spriteset.enemy_sprites[target.index].enemy_pose(1)
      end
    end
    $game_temp.forcing_battler = nil
    if @common_event_id > 0
      common_event = $data_common_events[@common_event_id]
      $game_system.battle_interpreter.setup(common_event.list, 0)
    end
    @phase4_step = 7
  end

  def update_phase4_step7
    
    # aqui vemos si el jugador esta muerto y si es jugador o ememigo...
    # estas lineas son para correrde regreso y la animacion inmovil....
    if @active_battler.is_a?(Game_Actor) and !@active_battler.dead?
      @spriteset.actor_sprites[@active_battler.index].pose(1)
    elsif !@active_battler.dead?
      @spriteset.enemy_sprites[@active_battler.index].enemy_pose(1)
    end

    $game_temp.forcing_battler = nil
    if @common_event_id > 0
      common_event = $data_common_events[@common_event_id]
      $game_system.battle_interpreter.setup(common_event.list, 0)
    end
    @phase4_step = 1
  end
  
# y esta extra... wsin esto no funciona correctamente...

  def update
    if $game_system.battle_interpreter.running?
      $game_system.battle_interpreter.update
      if $game_temp.forcing_battler == nil
        unless $game_system.battle_interpreter.running?
          unless judge
            setup_battle_event
          end
        end
        if @phase != 5
          @status_window.refresh
        end
      end
    end
    $game_system.update
    $game_screen.update
    if $game_system.timer_working and $game_system.timer == 0
      $game_temp.battle_abort = true
    end
    @help_window.update
    @party_command_window.update
    @actor_command_window.update
    @status_window.update
    @message_window.update
    @spriteset.update
    if $game_temp.transition_processing
      $game_temp.transition_processing = false
      if $game_temp.transition_name == ""
        Graphics.transition(20)
      else
        Graphics.transition(40, "Graphics/Transitions/" +
          $game_temp.transition_name)
      end
    end
    if $game_temp.message_window_showing
      return
    end
    if @spriteset.effect?
      return
    end
    if $game_temp.gameover
      $scene = Scene_Gameover.new
      return
    end
    if $game_temp.to_title
      $scene = Scene_Title.new
      return
    end
    if $game_temp.battle_abort
      $game_system.bgm_play($game_temp.map_bgm)
      battle_end(1)
      return
    end
    if @wait_count > 0
      @wait_count -= 1
      return
    end

    # esto pausa la battalla mientras el personaje se mueve
    for actor in @spriteset.actor_sprites
      if actor.moving
        return
      end
    end
    # y esto es para el enemigo... 
    for enemy in @spriteset.enemy_sprites
      if enemy.moving# and $game_system.animated_enemy
        return
      end
    end
    
    if $game_temp.forcing_battler == nil and
       $game_system.battle_interpreter.running?
      return
    end
    case @phase
    when 1
      update_phase1
    when 2
      update_phase2
    when 3
      update_phase3
    when 4
      update_phase4
    when 5
      update_phase5
    end
  end
  
#==============================================================================
# fin del fracmento
#==============================================================================
#------------------------------------------------------------------------------
#                                                  Scripted by: RPG
#                                                  editado por: cybersam
#                                                traducido por: Dark_Buster_XYZ
#------------------------------------------------------------------------------
end

Ambos sobre main
Por ejemplo:

* Animated_sprite
* Battle_animation
* Main


Para que funcione adecuadamente se deben poner en la carpeta Battlers los sprites detallados que vamos a usar, y que deben medir 64 x 64 cada cuadro de animacion y se aconseja que sean de 4 x minimo 7

ejemplo

Hilda.png


con el mismo nombre del personaje
y mirando al lado correcto
esto es tanto para personajes como para enemigos

Battlers para este Script:
Pack 1

ScreenShots:
batallalateral.jpg


Bueno veanlo aver si le sirve por que ami no me fue XD bueno a quien le sirva que postee y me ayude

sld2
 
Mensajes
9.007
Reacciones
224
Puntos
0
Ubicación
00 Qan[T]
-Nombre Del Script: Menu FFVII Personalizado para 1 solo personaje
-Version Del Script:no se
-Rpg Maker:XP

Un script de menu de FFVII personalizado por mi para que se de 1 solo jugador y algo distinto, pero por la forma nadie reconoceria que es de FFVII.
El autor original es... no se quien es...pero igual le doy credito.

Es MUY basico y facil de hacer, solo metí el script del menu original, y modifique todas las cajas/ventanas como se llamen.

Esta hecho para UN SOLO PERSONAJE, ni 2, ni 3 ni mas. La verdad es que no se si os funcionara, porque como esta hecho por el Maker mas gafe de la historia, pues...

-Caracteristicas:
Lo de siempre, pegar encima de Main. No hace falta cambiar el Scene_Menu original ni nada de eso. Se puede optar por usar el Chara o la Face en el menu.
(Esto no lo puse yo, ¿eh?)

-AVISO
Seguramente tendreis que cambiar las FUENTES del script, porque hay varias y estan divididas por algunos menus. Ahora esta la fuente "Book Antiqua" para todos los menus.


Código:
#********************************************************* 
#Final Fantasy Personalizado (Autor original: Yo no recordar quien hacer esto)
#********************************************************* 
#AVISO: Está configurado para usar faces, si quieres usar el charset
#del personaje, como en toda la vida del RPGXP, lee adelante.
#AVISO 2: Lo hice expresamente para que no aparezca el 
#nombre del personaje, porque si es de un sólo 
#personaje ya se debe saber cómo se llama, no?


#Si quieres usar faces:
#Crea una nueva carpeta en Characters y llámala Faces
#Para añadir faces, pon una imagen de 80 x 80 pixels en la carpeta Faces y llámala igual que el charaset.
#If text does not appear, right click and select Replace
#Si no quieres caras, ve a la línea 91
#ahí explica lo que tienes que hacer.


#======================================== 
#■ Window_Base 
#-------------------------------------------------------------------------- 
# Setting functions for the "Base" 
#======================================== 


class Window_Base < Window 


def draw_actor_face(actor, x, y) 
face = RPG::Cache.character("Faces/" + actor.character_name, actor.character_hue) 
fw = face.width 
fh = face.height 
src_rect = Rect.new(0, 0, fw, fh) 
self.contents.blt(x - fw / 23, y - fh, face, src_rect) 
end 
end 
def draw_actor_battler_graphic(actor, x, y) 
bitmap = RPG::Cache.battler(actor.battler_name, actor.battler_hue) 
cw = bitmap.width 
ch = bitmap.height 
src_rect = Rect.new(0, 0, cw, ch) 
self.contents.blt(x - cw / 2, y - ch, bitmap, src_rect) 
end 


#======================================== 
#■ Game_Map 
#-------------------------------------------------------------------------- 
# Setting functions for the Map 
#======================================== 
class Game_Map 


def name 
$map_infos[@map_id] 
end 
end 


#======================================== 
#■ Window_Title 
#-------------------------------------------------------------------------- 
# Setting functions for the Title 
#======================================== 
class Scene_Title 
$map_infos = load_data("Data/MapInfos.rxdata") 
for key in $map_infos.keys 
$map_infos[key] = $map_infos[key].name 
end 
end 




#======================================================== 
# ■ Window_MenuStatus 
#------------------------------------------------------------------------ 
# Sets up the Choosing. 
#======================================================== 


class Window_MenuStatus < Window_Selectable 
#-------------------------------------------------------------------------- 
# Set up 
#-------------------------------------------------------------------------- 
def initialize 
super(0, 0, 435, 135) 
self.contents = Bitmap.new(width - 32, height - 32) 
self.contents.font.name = "Book Antiqua" 
self.contents.font.size = 25
refresh 
self.active = false 
self.index = -1 
end 
#-------------------------------------------------------------------------- 
# Drawing Info on Screen 
#-------------------------------------------------------------------------- 
def refresh 
self.contents.clear 
@item_max = $game_party.actors.size 
for i in 0...$game_party.actors.size 
x = 94 
y = i * 55 
actor = $game_party.actors[i] 
draw_actor_face(actor, 12, y + 90) #Para quitar las faces, pon # al comienzo de esta línea
#draw_actor_graphic(actor, 48, y + 65) #y quita el # de ésta línea.
draw_actor_class(actor, x + 80, y) #Para volver a poner faces, pon un # en la linea 92 y quítalo en la 91
draw_actor_level(actor, x, y + 18) 
draw_actor_state(actor, x + 200, y) 
draw_actor_exp(actor, x+ 144, y + 38) 
draw_actor_hp(actor, x, y + 38) 
draw_actor_sp(actor, x, y + 58) 
end 
end 
#-------------------------------------------------------------------------- 
# Update of Cursor 
#-------------------------------------------------------------------------- 
def update_cursor_rect 
if @index < 0 
self.cursor_rect.empty 
else 
self.cursor_rect.set(0, @index * 116, self.width - 32, 96) 
end 
end 
end 


#=======================================# 
# ■Window_GameStats # 
# written by AcedentProne # 
#-----------------------------------------------------------------------# 


class Window_GameStats < Window_Base 
def initialize 
super(0, 0, 160, 80) 
self.contents = Bitmap.new(width - 32, height - 32) 
self.contents.font.name = "Book Antiqua" 
self.contents.font.size = 20
refresh 
end 


def refresh 
self.contents.clear 
self.contents.font.color = system_color 
# Draw "Time" 
@total_sec = Graphics.frame_count / Graphics.frame_rate 
hour = @total_sec / 60 / 60 
min = @total_sec / 60 % 60 
sec = @total_sec % 60 
text = sprintf("%02d:%02d:%02d", hour, min, sec) 
self.contents.font.color = normal_color 
self.contents.draw_text(4, 6, 120, 32, text, 2) 
self.contents.font.color = system_color 
self.contents.draw_text(4, -10, 120, 32, "Tiempo") 
#Drawing Gold 
self.contents.font.color = normal_color 
self.contents.draw_text(4, 22, 120, 32,$game_party.gold.to_s + " " +$data_system.words.gold, 2) 
self.contents.font.color = system_color 
self.contents.draw_text(4, 22, 120, 32, $data_system.words.gold, 2) 
end 
#-------------------------------------------------------------------------- 
# Update of The count 




#-------------------------------------------------------------------------- 
def update 
super 
if Graphics.frame_count / Graphics.frame_rate != @total_sec 
refresh 
end 
end 
end 


#======================================================== 
# ■ Window_Mapname 
#------------------------------------------------------------------------ 
#  Draws the Map name 
#======================================================== 


class Window_Mapname < Window_Base 
#-------------------------------------------------------------------------- 
# Set up 
#-------------------------------------------------------------------------- 
def initialize 
super(0, 0, 320, 60) 
self.contents = Bitmap.new(width - 52, height - 32) 
self.contents.font.name = "Book Antiqua" 
self.contents.font.size = 25 
refresh 
end 
#-------------------------------------------------------------------------- 
# Draws info on screen 
#-------------------------------------------------------------------------- 
def refresh 
self.contents.clear 


# Map Name 
#map = $game_map.name 
self.contents.font.color = system_color 
self.contents.draw_text(4, 0, 220, 32, "Localización") 
self.contents.font.color = normal_color 
self.contents.draw_text(175, 0, 80, 32, $game_map.name) 
end 
end 


#======================================================== 
# ■ Scene_Menu 
#------------------------------------------------------------------------ 
# FF7 menu laytout as requested by AcedentProne. 
#======================================================== 


class Scene_Menu 
#--------------------------- edit------------------------------- 
attr_reader :status_window 
#/--------------------------- edit------------------------------- 


def initialize(menu_index = 0) 
@menu_index = menu_index 
end 


def main 
s1 = $data_system.words.item 
s2 = $data_system.words.skill 
s3 = $data_system.words.equip 
s4 = "Estado" 
s5 = "Guardar" 
s6 = "Salir" 



#--------------------------- edit------------------------------- 
# Command menu 
# Size = Screen height - border sizes - 
# GameStatus menu - Spacing from GameStatus 
@command_window = Window_Command.new(160, [s1, s2, s3, s4, s5, s6,]) 
@command_window.x = 640 - @command_window.width 
@command_window.y = 195
@command_window.z = 110 
@command_window.index = @menu_index 
if $game_party.actors.size == 0 
@command_window.disable_item(0) 
@command_window.disable_item(1) 
@command_window.disable_item(2) 
@command_window.disable_item(3) 
end 
if $game_system.save_disabled 
@command_window.disable_item(4) 
end 
@map = Window_Mapname.new 
@map.x = 640 - @map.width 
@map.y = 480 - @map.height - 1 
@map.z = 110 



# Lower right box 
@game_stats_window = Window_GameStats.new 
@game_stats_window.x = 480 - @game_stats_window.width 
@game_stats_window.y = 640 - @command_window.height - @game_stats_window.height + 3 
@game_stats_window.z =110 



# Status window 
@status_window = Window_MenuStatus.new 
@status_window.x = 100 
@status_window.y = 3 
@status_window.z = 100 



Graphics.transition 
loop do 
Graphics.update 
Input.update 
update 
if $scene != self 
break 
end 
end 
Graphics.freeze 
@command_window.dispose 
@game_stats_window.dispose 
@status_window.dispose 
@map.dispose 
end 
#-------------------------------------------------------------------- 
# Updating 
#-------------------------------------------------------------------- 
def update 
@command_window.update 
@game_stats_window.update 
@status_window.update 
@map.update 
if @command_window.active 
update_command 
return 
end 
if @status_window.active 
update_status 
return 
end 
end 
#-------------------------------------------------------------------- 
# Updating the Command Selection 
#-------------------------------------------------------------------- 
def update_command 
# If B button is pused 
if Input.trigger?(Input::B) 
# Plays assigned SE 
$game_system.se_play($data_system.cancel_se) 
# Go to Map 
$scene = Scene_Map.new 
return 
end 
# If C button is pused 
if Input.trigger?(Input::C) 
# Checks actor size 
if $game_party.actors.size == 0 and @command_window.index < 4 
# plays SE 
$game_system.se_play($data_system.buzzer_se) 
return 
end 
case @command_window.index 
when 0 
$game_system.se_play($data_system.decision_se) 
$scene = Scene_Item.new 
when 1 
$game_system.se_play($data_system.decision_se) 
@command_window.active = false 
@status_window.active = true 
@status_window.index = 0 
when 2 
$game_system.se_play($data_system.decision_se) 
@command_window.active = false 
@status_window.active = true 
@status_window.index = 0 
when 3 
$game_system.se_play($data_system.decision_se) 
@command_window.active = false 
@status_window.active = true 
@status_window.index = 0 
when 4 
if $game_system.save_disabled 
$game_system.se_play($data_system.buzzer_se) 
return 
end 
$game_system.se_play($data_system.decision_se) 
$scene = Scene_Save.new 
when 5 
$game_system.se_play($data_system.decision_se) 
$scene = Scene_End.new 
when 6 
$game_system.se_play($data_system.decision_se)# Fonction qui perrmets de jouer le son d'accés au menu. 
@checker = 0 
@command_window.active = false 
@status_window.active = true 
@status_window.index = 0 
end 
return 
end 
end 
#-------------------------------------------------------------------- 
# Updating Status Screen 
#-------------------------------------------------------------------- 


def update_status 
if Input.trigger?(Input::B) 
$game_system.se_play($data_system.cancel_se) 
@command_window.active = true 
@status_window.active = false 
@status_window.index = -1 
return 
end 
if Input.trigger?(Input::C) 
case @command_window.index 
when 1 
if $game_party.actors[@status_window.index].restriction >= 2 
$game_system.se_play($data_system.buzzer_se) 
return 
end 
$game_system.se_play($data_system.decision_se) 
$scene = Scene_Skill.new(@status_window.index) 
when 2 
$game_system.se_play($data_system.decision_se) 
$scene = Scene_Equip.new(@status_window.index) 
when 3 
$game_system.se_play($data_system.decision_se) 
$scene = Scene_Status.new(@status_window.index) 
when 6 
$game_system.se_play($data_system.decision_se)# Fonction qui perrmets de jouer le son d'accés au menu. 
if @checker == 0 
@changer = $game_party.actors[@status_window.index] 
@where = @status_window.index 
@checker = 1 
else 
$game_party.actors[@where] = $game_party.actors[@status_window.index] 
$game_party.actors[@status_window.index] = @changer 
@checker = 0 
@status_window.refresh 
end 
end 
return 
end 
end
end

-Screen
http://img179.imageshack.us/img179/9863/ff7menupjw2.png

-credito
Desconocido...
 
Mensajes
9.007
Reacciones
224
Puntos
0
Ubicación
00 Qan[T]
-Nombre Del Script:Banco
-Version Del Script:no se
-Rpg Maker:XP

Este script creo que no tiene explicacion...
porque parece obvio que el nombre lo dice todo. xDD

Crear clase nueva arriba de Main y llamarla Dipositery. Dentro pegar el siguiente script:

Código:
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_

#_/  ?Espace de Stockage - KGC_Depository ? Translated by Ojiro -

#_/----------------------------------------------------------------------------

#_/ Espace de stockage pour objets et monaie.

#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_





class Window_DepositoryCommand < Window_Selectable

 # ?Nom des commandes de l'espace de stockage

 DEPOSITORY_COMMAND = [

"Depositar",    # Déposer

"Retirar",  # Retirer

"Almacenar",   # Stocker

"Tomar"  # Prendre

 ]

 # ?Définitions des commandes

 DEPOSITORY_HELP = [

"Depositar Gold",      # Déposer de l'argent

"Retirar Gold",  # Retirer de l'argent

"Almacenar un objeto",     # Stocker un objet

"Tomar un objeto"  # Prendre un objet

 ]

end



class Window_DepositoryGold < Window_Base

 # ?Nombre de chiffres maximal pour le dépot de monnaie

 GOLD_DIGITS = 7

end



class Scene_Depository

 DEPOSIT_GOLD = "Insertar la cantidad a depositar"

 WDEPOSIT_GOLD = "Insertar la cantidad a retirar"

 DEPOSIT_ITEM = "¿Cuanto quiere depositar?"

 WDEPOSIT_ITEM = "¿Cuanto quiere retirar?"

end



#???????????????????????????????????????



#--------------------------------------------------------------------------

# ? Appel de l'espace de stockage

#--------------------------------------------------------------------------

def call_depository

 $game_player.straighten

 # Affiche l'espace de stockage

 $scene = Scene_Depository.new

end



#???????????????????????????????????????



#=========================================

# ¦ Game_Party

#------------------------------------------------------------------------------

#  Récupère les informations sur la monnaie et les objets possédés dans

# $game_party

#==========================================



class Game_Party

 #--------------------------------------------------------------------------

 # ? Initialisation

 #--------------------------------------------------------------------------

 alias initialize_KGC_Depository initialize

 def initialize

# Exécute le processus d'origine

initialize_KGC_Depository



@deposit_gold = 0

@deposit_item = []

@deposit_weapon = []

@deposit_armor = []

 end

 #--------------------------------------------------------------------------

 # ? Récupère l'information sur la monnaie

 #--------------------------------------------------------------------------

 def deposit_gold

@deposit_gold = 0 if @deposit_gold == nil

return @deposit_gold

 end

 #--------------------------------------------------------------------------

 # ? Récupère l'information sur la monnaie récupérée

 #  number : Montant a récuperer

 #--------------------------------------------------------------------------

 def gain_deposit_gold(number)

@deposit_gold = 0 if @deposit_gold == nil

@deposit_gold += number

 end

 #--------------------------------------------------------------------------

 # ? Récupère l'information sur la monnaie déposée

 #  number : Montant à déposer

 #--------------------------------------------------------------------------

 def lose_deposit_gold(number)

self.gain_deposit_gold(-number)

 end

 #--------------------------------------------------------------------------

 # ? Récupère l'information sur les objets

 #  id : ID

 #--------------------------------------------------------------------------

 def deposit_item_number(id)

@deposit_item = [] if @deposit_item == nil

return @deposit_item[id] != nil ? @deposit_item[id] : 0

 end

 #--------------------------------------------------------------------------

 # ? Acquisition de l'objet

 #  id  : ID

 #  number : Quantité

 #--------------------------------------------------------------------------

 def gain_deposit_item(id, number)

@deposit_item = [] if @deposit_item == nil

@deposit_item[id] = 0 if @deposit_item[id] == nil

@deposit_item[id] += number

 end

 #--------------------------------------------------------------------------

 # ? Dépôt de l'objet

 #  id  : ID

 #  number : Quantité

 #--------------------------------------------------------------------------

 def lose_deposit_item(id, number)

self.gain_deposit_item(id, -number)

 end

 #--------------------------------------------------------------------------

 # ? Récupère l'information sur les armes

 #  id : ID

 #--------------------------------------------------------------------------

 def deposit_weapon_number(id)

@deposit_weapon = [] if @deposit_weapon == nil

return @deposit_weapon[id] != nil ? @deposit_weapon[id] : 0

 end

 #--------------------------------------------------------------------------

 # ? Acquisition de l'arme

 #  id  : ID

 #  number : Quantité

 #--------------------------------------------------------------------------

 def gain_deposit_weapon(id, number)

@deposit_weapon = [] if @deposit_weapon == nil

@deposit_weapon[id] = 0 if @deposit_weapon[id] == nil

@deposit_weapon[id] += number

 end

 #--------------------------------------------------------------------------

 # ? Dépôt de l'arme

 #  id  : ID

 #  number : Quantité

 #--------------------------------------------------------------------------

 def lose_deposit_weapon(id, number)

self.gain_deposit_weapon(id, -number)

 end

 #--------------------------------------------------------------------------

 # ? Récupère l'information sur les armures

 #  id : ID

 #--------------------------------------------------------------------------

 def deposit_armor_number(id)

@deposit_armor = [] if @deposit_armor == nil

return @deposit_armor[id] != nil ? @deposit_armor[id] : 0

 end

 #--------------------------------------------------------------------------

 # ? Acquisition de l'armure

 #  id  : ID

 #  number : Quantité

 #--------------------------------------------------------------------------

 def gain_deposit_armor(id, number)

@deposit_armor = [] if @deposit_armor == nil

@deposit_armor[id] = 0 if @deposit_armor[id] == nil

@deposit_armor[id] += number

 end

 #--------------------------------------------------------------------------

 # ? Dépôt de l'armure

 #  id  : ID

 #  number : Quantité

 #--------------------------------------------------------------------------

 def lose_deposit_armor(id, number)

self.gain_deposit_armor(id, -number)

 end

end



#???????????????????????????????????????



#===========================================

# ¦ Window_DepositoryCommand

#------------------------------------------------------------------------------

#  Ecran de sélection d'une commande de l'espace de stockage

#========================================



class Window_DepositoryCommand < Window_Selectable

 #--------------------------------------------------------------------------

 # ? Initialisation

 #--------------------------------------------------------------------------

 def initialize

super(0, 64, 640, 64)

self.contents = Bitmap.new(width - 32, height - 32)

# ?????????

@commands = DEPOSITORY_COMMAND

@item_max = @commands.size

@column_max = @commands.size

@item_width = (width - 32) / @commands.size

self.back_opacity = 160

self.index = 0

refresh

 end

 #--------------------------------------------------------------------------

 # ? Actualisation

 #--------------------------------------------------------------------------

 def refresh

for i in [email protected]

  rect = Rect.new(@item_width * i, 0, @item_width, 32)

  self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))

  self.contents.font.color = system_color

  self.contents.draw_text(rect, @commands[i], 1)

end

 end

#--------------------------------------------------------------------------

 # ? Curseur

 #--------------------------------------------------------------------------

 def update_cursor_rect

if index != -1

  self.cursor_rect.set(@item_width * index, 0, @item_width, 32)

end

 end

 #--------------------------------------------------------------------------

 # ? Actualisation de la fenêtre d'aide

 #--------------------------------------------------------------------------

 def update_help

@help_window.set_text(DEPOSITORY_HELP[self.index])

 end

end



#???????????????????????????????????????



#=========================================

# ¦ Window_DepositoryGold

#------------------------------------------------------------------------------

#  Indication de la quantité/valeur de la monnaie/objet.

#==========================================



class Window_DepositoryGold < Window_Base

 #--------------------------------------------------------------------------

 # ? Initialisation

 #--------------------------------------------------------------------------

 def initialize

super(0, 128, 640, 352)

@digits_max = GOLD_DIGITS

# Calcul de la largeur du curseur à partir du nombre de chiffres à entrer

dummy_bitmap = Bitmap.new(32, 32)

@cursor_width = dummy_bitmap.text_size("0").width + 8

dummy_bitmap.dispose

self.contents = Bitmap.new(width - 32, height - 32)

self.back_opacity = 160

self.active = false

self.visible = false

@cursor_position = 0

@max = 0

@price = 0

@index = 0

 end

 #--------------------------------------------------------------------------

 # ? Acquisition de la quantité inséré

 #--------------------------------------------------------------------------

 def price

return @price

 end

 #--------------------------------------------------------------------------

 # ? Option de la quantité

 #  np : Nouvelle quantité

 #--------------------------------------------------------------------------

 def price=(np)

@price = [[np, 0].max, @max].min

redraw_price

 end

 #--------------------------------------------------------------------------

 # ? Reinitialisation

 #  type : Type

 #--------------------------------------------------------------------------

 def reset(type)

@price = 0

@index = @digits_max - 1

refresh(type)

 end

 #--------------------------------------------------------------------------

 # ? Actualisation

 #  type : Type

 #--------------------------------------------------------------------------

 def refresh(type)

# Affiche la quantité

self.contents.clear

domination = $data_system.words.gold

cx = contents.text_size(domination).width

@cursor_position = 332 - cx - @cursor_width * @digits_max

self.contents.font.color = system_color

self.contents.draw_text(0, 0, 608, 32, "Gold que tienes:")

self.contents.draw_text(0, 64, 608, 32, "Depósito:")

if type == 0

  self.contents.draw_text(0, 128, 608, 32, "Cantidad:")

  @max = $game_party.gold

else

  self.contents.draw_text(0, 128, 608, 32, "Retirada:")

  @max = [10 ** @digits_max - $game_party.gold - 1, $game_party.deposit_gold].min

end

self.contents.font.color = normal_color

self.contents.draw_text(4, 32, 326 - cx, 32, $game_party.gold.to_s, 2)

self.contents.font.color = system_color

self.contents.draw_text(332 - cx, 32, cx, 32, domination, 2)

self.contents.font.color = normal_color

self.contents.draw_text(4, 96, 326 - cx, 32, $game_party.deposit_gold.to_s, 2)

self.contents.font.color = system_color

self.contents.draw_text(332 - cx, 96, cx, 32, domination, 2)

redraw_price

 end

 #--------------------------------------------------------------------------

 # ? Quantité re-affiché

 #--------------------------------------------------------------------------

 def redraw_price

domination = $data_system.words.gold

cx = contents.text_size(domination).width

self.contents.fill_rect(0, 160, 608, 32, Color.new(0, 0, 0, 0))

self.contents.font.color = normal_color

text = sprintf("%0#{@digits_max}d", self.price)

for i in 0...text.length

  x = @cursor_position + (i - 1) * @cursor_width

  self.contents.draw_text(x, 160, 32, 32, text[i, 1], 2)

end

self.contents.font.color = system_color

self.contents.draw_text(332 - cx, 160, cx, 32, domination, 2)

 end

 #--------------------------------------------------------------------------

 # ? Actualisation du curseur

 #--------------------------------------------------------------------------

 def update_cursor_rect

x = @cursor_position + @index * @cursor_width

self.cursor_rect.set(x, 160, @cursor_width, 32)

 end

 #--------------------------------------------------------------------------

 # ? Actualisation

 #--------------------------------------------------------------------------

 def update

super

return unless self.active

# Lors d'un appui HAUT ou BAS

if Input.repeat?(Input::UP) || Input.repeat?(Input::DOWN)

  $game_system.se_play($data_system.cursor_se)

  place = 10 ** (@digits_max - 1 - @index)

  n = self.price / place % 10

  self.price -= n * place

  n = (n + 1) % 10 if Input.repeat?(Input::UP)

  n = (n + 9) % 10 if Input.repeat?(Input::DOWN)

  self.price += n * place

end

if Input.repeat?(Input::RIGHT)

  if @digits_max >= 2

 $game_system.se_play($data_system.cursor_se)

 @index = (@index + 1) % @digits_max

  end

end

if Input.repeat?(Input::LEFT)

  if @digits_max >= 2

 $game_system.se_play($data_system.cursor_se)

 @index = (@index + @digits_max - 1) % @digits_max

  end

end

update_cursor_rect

 end

end



#???????????????????????????????????????



#===========================================

# ¦ Window_DepositoryItem

#------------------------------------------------------------------------------

#  Conception d'un sommaire pour les objets

#===========================================



class Window_DepositoryItem < Window_Selectable

 #--------------------------------------------------------------------------

 # ? Initialisation

 #--------------------------------------------------------------------------

 def initialize

super(0, 128, 640, 352)

self.back_opacity = 160

self.active = false

self.visible = false

@column_max = 2

self.index = 0

 end

 #--------------------------------------------------------------------------

 # ? Récupère l'information sur les objets

 #--------------------------------------------------------------------------

 def item

return @data[self.index]

 end

 #--------------------------------------------------------------------------

 # ? Actualisation

 #  type : Type

 #--------------------------------------------------------------------------

 def refresh(type)

if self.contents != nil

  self.contents.dispose

  self.contents = nil

end

@data = []

self.index = 0

# Ajoute l'objet / arme / armure x

if type == 0

  for i in 1...$data_items.size

 if $game_party.item_number(i) > 0

   @data.push($data_items[i])

 end

  end

  for i in 1...$data_weapons.size

 if $game_party.weapon_number(i) > 0

   @data.push($data_weapons[i])

 end

  end

  for i in 1...$data_armors.size

 if $game_party.armor_number(i) > 0

   @data.push($data_armors[i])

 end

  end

else

  for i in 1...$data_items.size

 if $game_party.deposit_item_number(i) > 0

   @data.push($data_items[i])

 end

  end

  for i in 1...$data_weapons.size

 if $game_party.deposit_weapon_number(i) > 0

   @data.push($data_weapons[i])

 end

  end

  for i in 1...$data_armors.size

 if $game_party.deposit_armor_number(i) > 0

   @data.push($data_armors[i])

 end

  end



end

# Si le nombre d'objet n'est pas de 0 :

@item_max = @data.size

if @item_max > 0

  self.contents = Bitmap.new(width - 32, row_max * 32)

  for i in 0...@item_max

 draw_item(i, type)

  end

end

 end

#--------------------------------------------------------------------------

 # ? Affichage de l'objet

 #  index : Nombre d'objets

 #  type  : Type

 #--------------------------------------------------------------------------

 def draw_item(index, type)

item = @data[index]

case item

when RPG::Item

  number = type == 0 ? $game_party.item_number(item.id) :

 $game_party.deposit_item_number(item.id)

when RPG::Weapon

  number = type == 0 ? $game_party.weapon_number(item.id) :

 $game_party.deposit_weapon_number(item.id)

when RPG::Armor

  number = type == 0 ? $game_party.armor_number(item.id) :

 $game_party.deposit_armor_number(item.id)

end

x = 4 + index % 2 * (288 + 32)

y = index / 2 * 32

rect = Rect.new(x, y, self.width / @column_max - 32, 32)

self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))

bitmap = RPG::Cache.icon(item.icon_name)

self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24))

self.contents.draw_text(x + 28, y, 212, 32, item.name, 0)

self.contents.draw_text(x + 240, y, 16, 32, ":", 1)

self.contents.draw_text(x + 256, y, 24, 32, number.to_s, 2)

 end

 #--------------------------------------------------------------------------

 # ? Actualisation de la fenêtre d'aide

 #--------------------------------------------------------------------------

 def update_help

@help_window.set_text(self.item == nil ? "" : self.item.description)

 end

end



#???????????????????????????????????????



#=================================-==========

# ¦ Window_DepositoryNumber

#------------------------------------------------------------------------------

#  Fenêtre de l'insertion numérique

#===========================================



class Window_DepositoryNumber < Window_Base

 #--------------------------------------------------------------------------

 # ? Initialisation

 #--------------------------------------------------------------------------

 def initialize

@digits_max = 2

@number = 0

# Calcul de la largeur du curseur en fonction du nombre de chiffres

dummy_bitmap = Bitmap.new(32, 32)

@cursor_width = dummy_bitmap.text_size("0").width + 8

dummy_bitmap.dispose

@default_size = @cursor_width * @digits_max + 32

super(0, 0, @default_size, 128)

self.contents = Bitmap.new(width - 32, height - 32)

self.z = 1000

self.back_opacity = 160

self.active = false

self.visible = false

@index = 0

@item = nil

refresh

update_cursor_rect

 end

 #--------------------------------------------------------------------------

 # ? Option de l'objet

 #  item : Objet

 #--------------------------------------------------------------------------

 def item=(item)

@item = item

 end

 #--------------------------------------------------------------------------

 # ? Acquisition de la valeur numérique

 #--------------------------------------------------------------------------

 def number

return @number

 end

 #--------------------------------------------------------------------------

 # ? Option de la valeur numérique

 #  number : Nouvelle valeur numérique

 #--------------------------------------------------------------------------

 def number=(number)

@number = [[number, 0].max, @max].min

refresh

 end

 #--------------------------------------------------------------------------

 # ? Actualisation du curseur

 #--------------------------------------------------------------------------

 def update_cursor_rect

self.cursor_rect.set(@index * @cursor_width, 32, @cursor_width, 32)

 end

 #--------------------------------------------------------------------------

 # ? Reinitilisation

 #--------------------------------------------------------------------------

 def reset(type)

@number = 0

@index = @digits_max - 1

if type == 0

  case @item

  when RPG::Item

 @max = $game_party.item_number(@item.id)

 dep = $game_party.deposit_item_number(@item.id)

  when RPG::Weapon

 @max = $game_party.weapon_number(@item.id)

 dep = $game_party.deposit_weapon_number(@item.id)

  when RPG::Armor

 @max = $game_party.armor_number(@item.id)

 dep = $game_party.deposit_armor_number(@item.id)

  end

  # Affiche la quantité déposé

  self.contents.fill_rect(0, 64, width - 32, 32, Color.new(0, 0, 0, 0))

  self.contents.font.color = system_color

  self.contents.draw_text(0, 64, width - 32, 32, "Depósito:#{dep}")

else

  case @item

  when RPG::Item

 @max = [$game_party.deposit_item_number(@item.id),

   10 ** @digits_max - $game_party.item_number(@item.id) - 1].min

 having = $game_party.item_number(@item.id)

  when RPG::Weapon

 @max = [$game_party.deposit_weapon_number(@item.id),

   10 ** @digits_max - $game_party.weapon_number(@item.id) - 1].min

 having = $game_party.weapon_number(@item.id)

  when RPG::Armor

 @max = [$game_party.deposit_armor_number(@item.id),

   10 ** @digits_max - $game_party.armor_number(@item.id) - 1].min

 having = $game_party.armor_number(@item.id)

  end

  # Affiche la quantité possedé

  self.contents.fill_rect(0, 64, width - 32, 32, Color.new(0, 0, 0, 0))

  self.contents.font.color = system_color

  self.contents.draw_text(0, 64, width - 32, 32, "PoseÃdo:#{having}")

end

refresh

 end

 #--------------------------------------------------------------------------

 # ? Actualisation

 #--------------------------------------------------------------------------

 def refresh

self.contents.fill_rect(0, 32, width - 32, 32, Color.new(0, 0, 0, 0))

self.contents.font.color = normal_color

s = sprintf("%0*d", @digits_max, @number)

for i in 0...@digits_max

  self.contents.draw_text(i * @cursor_width + 4, 32, 32, 32, s[i,1])

end

 end

 #--------------------------------------------------------------------------

 # ? Option du personnage

 #  string : Met en place les options

 #--------------------------------------------------------------------------

 def set_text(string = " ")

self.resize(self.contents.text_size(string).width + 40)

self.contents.fill_rect(0, 0, width - 32, 32, Color.new(0, 0, 0, 0))

self.contents.font.color = normal_color

self.contents.draw_text(0, 0, width - 32, 32, string, 1)

refresh

centering

 end

 #--------------------------------------------------------------------------

 # ? Modification de la taille

 #  nw : Nouvelle largeur

 #--------------------------------------------------------------------------

 def resize(nw)

self.width = nw

buf = self.contents.dup

self.contents.dispose

self.contents = Bitmap.new(nw - 32, 96)

self.contents.blt(0, 0, buf, buf.rect)

buf.dispose

 end

 #--------------------------------------------------------------------------

 # ? Mouvement central

 #--------------------------------------------------------------------------

 def centering

self.x = 320 - self.width / 2

self.y = 240 - self.height / 2

 end

 #--------------------------------------------------------------------------

 # ? Actualisation

 #--------------------------------------------------------------------------

 def update

super

return unless self.active

# Lors d'un appui HAUT ou BAS

if Input.repeat?(Input::UP) || Input.repeat?(Input::DOWN)

  $game_system.se_play($data_system.cursor_se)

  place = 10 ** (@digits_max - 1 - @index)

  n = self.number / place % 10

  self.number -= n * place

  n = (n + 1) % 10 if Input.repeat?(Input::UP)

  n = (n + 9) % 10 if Input.repeat?(Input::DOWN)

  self.number += n * place

  refresh

end

if Input.repeat?(Input::RIGHT)

  if @digits_max >= 2

 $game_system.se_play($data_system.cursor_se)

 @index = (@index + 1) % @digits_max

  end

end

if Input.repeat?(Input::LEFT)

  if @digits_max >= 2

 $game_system.se_play($data_system.cursor_se)

 @index = (@index + @digits_max - 1) % @digits_max

  end

end

update_cursor_rect

 end

end

#???????????????????????????????????????



#===========================================

# ¦ Scene_Depository

#------------------------------------------------------------------------------

#  "Class" qui proccède à l'espace de stockage

#===========================================



class Scene_Depository

 #--------------------------------------------------------------------------

 # ? ?????

 #--------------------------------------------------------------------------

 def main

# Compilation des sprites

@spriteset = Spriteset_Map.new

# Affiche des fenêtres multiples

@dummy_window = Window_Base.new(0, 128, 640, 352)

@help_window = Window_Help.new

@dummy_window.back_opacity = 160

@help_window.back_opacity = 160

@command_window = Window_DepositoryCommand.new

@gold_window = Window_DepositoryGold.new

@item_window = Window_DepositoryItem.new

@number_window = Window_DepositoryNumber.new

# Association de la fenêtre d'affichage

@command_window.help_window = @help_window

@item_window.help_window = @help_window

# Exécute la transition

Graphics.transition

# Boucle Principale

loop do

  # Actualise les images

  Graphics.update

  # Actualise l'information d'insertion

  Input.update

  # Actualisation

  update

  # Brise la boucle si les images changent

  if $scene != self

 break

  end

end

# Préparation de la Transition

Graphics.freeze

# Relais

@spriteset.dispose

@dummy_window.dispose

@help_window.dispose

@command_window.dispose

@gold_window.dispose

@item_window.dispose

@number_window.dispose

 end

 #--------------------------------------------------------------------------

 # ? Actualisation

 #--------------------------------------------------------------------------

 def update

# Actualisation des fenêtres

@dummy_window.update

@help_window.update

@command_window.update

@gold_window.update

@item_window.update

@number_window.update

if @command_window.active

  update_command

  return

end

if @gold_window.active

  update_gold

  return

end

if @item_window.active

  update_item

  return

end

if @number_window.active

  update_number

  return

end

 end

 #--------------------------------------------------------------------------

 # ? Actualisation lorsque une fenêtre de commande est active

 #--------------------------------------------------------------------------

 def update_command

# Lors d'un appui sur la touche B

if Input.trigger?(Input::B)

  $game_system.se_play($data_system.cancel_se)

  $scene = Scene_Map.new

  return

end

# Lors d'un appui sur la touche C

if Input.trigger?(Input::C)

  $game_system.se_play($data_system.decision_se)

  case @command_window.index

  when 0

 @gold_window.active = true

 @gold_window.visible = true

 @gold_window.reset(0)

 @help_window.set_text(DEPOSIT_GOLD)

  when 1

 @gold_window.active = true

 @gold_window.visible = true

 @gold_window.reset(1)

 @help_window.set_text(WDEPOSIT_GOLD)

  when 2

 @item_window.active = true

 @item_window.visible = true

 @item_window.refresh(0)

  when 3

 @item_window.active = true

 @item_window.visible = true

 @item_window.refresh(1)

  end

  @command_window.active = false

  @dummy_window.visible = false

  return

end

 end

 #--------------------------------------------------------------------------

 # ? Actualisation lors d'un appui pendant la fenetre de monnaie

 #--------------------------------------------------------------------------

 def update_gold

# Lors d'un appui sur la touche B

if Input.trigger?(Input::B)

  $game_system.se_play($data_system.cancel_se)

  @command_window.active = true

  @gold_window.active = false

  @gold_window.visible = false

  @dummy_window.visible = true

  return

end

# Lors d'un appui sur la touche C

if Input.trigger?(Input::C)

  price = @gold_window.price

  if price == 0

 $game_system.se_play($data_system.decision_se)

 @command_window.active = true

 @gold_window.active = false

 @gold_window.visible = false

 @dummy_window.visible = true

 return

  end

  $game_system.se_play($data_system.shop_se)

  case @command_window.index

  when 0 

 $game_party.lose_gold(price)

 $game_party.gain_deposit_gold(price)

  when 1 

 $game_party.gain_gold(price)

 $game_party.lose_deposit_gold(price)

  end

  # ??????????????

  @gold_window.reset(@command_window.index)

  return

end

 end

 #--------------------------------------------------------------------------

 # ? Actualisation lors d'un appui pendant la fenetre d'objet

 #--------------------------------------------------------------------------

 def update_item

# Lors d'un appui sur la touche B

if Input.trigger?(Input::B)

  $game_system.se_play($data_system.cancel_se)

  @command_window.active = true

  @item_window.active = false

  @item_window.visible = false

  @dummy_window.visible = true

  return

end

# Lors d'un appui sur la touche C

if Input.trigger?(Input::C)

  @item = @item_window.item

  if @item == nil

 $game_system.se_play($data_system.buzzer_se)

 return

  end

  @number_window.item = @item

  $game_system.se_play($data_system.decision_se)

  case @command_window.index

  when 2

 @number_window.set_text(DEPOSIT_ITEM)

  when 3

 @number_window.set_text(WDEPOSIT_ITEM)

  end

  @number_window.reset(@command_window.index - 2)

  # ????????????

  @item_window.active = false

  @number_window.active = true

  @number_window.visible = true

  return

end

 end

 #--------------------------------------------------------------------------

 # ? Actualisation lors d'un appui pendant la fenetre de nombres

 #--------------------------------------------------------------------------

 def update_number

# Lors d'un appui sur la touche B

if Input.trigger?(Input::B)

  $game_system.se_play($data_system.cancel_se)

  @item_window.active = true

  @number_window.active = false

  @number_window.visible = false

  return

end

# Lors d'un appui sur la touche C

if Input.trigger?(Input::C)

  $game_system.se_play($data_system.decision_se)

  number = @number_window.number

  case @command_window.index

  when 2

 case @item

 when RPG::Item

   $game_party.lose_item(@item.id, number)

   $game_party.gain_deposit_item(@item.id, number)

 when RPG::Weapon

   $game_party.lose_weapon(@item.id, number)

   $game_party.gain_deposit_weapon(@item.id, number)

 when RPG::Armor

   $game_party.lose_armor(@item.id, number)

   $game_party.gain_deposit_armor(@item.id, number)

 end

  when 3

 case @item

 when RPG::Item

   $game_party.gain_item(@item.id, number)

   $game_party.lose_deposit_item(@item.id, number)

 when RPG::Weapon

   $game_party.gain_weapon(@item.id, number)

   $game_party.lose_deposit_weapon(@item.id, number)

 when RPG::Armor

   $game_party.gain_armor(@item.id, number)

   $game_party.lose_deposit_armor(@item.id, number)

 end

  end

  @item_window.refresh(@command_window.index - 2)

  @item_window.active = true

  @number_window.active = false

  @number_window.visible = false

  return

end

 end

end

Para llamarlo, simplemente en el comando de 'Llamar script...' le ponen esto:
Código:
$scene = Scene_Depository.new

-creditos
Ojiro
 
Mensajes
91
Reacciones
0
Puntos
0
Ubicación
En medio de la infección del "F-virus" 0.o
JA!!!
Yo conosco ese script, de hecho, es uno de los más fáciles de modificar, tanto es así que yo le había cambiado la parte de depositar dinero, también puedes cambiar algunas líneas del menu principal (cuando pausas que sale el menu de equipo y eso), para que en cualquier parte puedas usar el banco, aunque creo que esa idea mía no es muy útil, pero lo puedes usar de base para un script de intercambio de tu "party", como en el chrono trigger!!!
Buen aporte, yo perdí todos mis scripts pero gracias a tí ya tengo de nuevo el del banco...
MWAHAHAHA
 
Última edición:
Mensajes
9.007
Reacciones
224
Puntos
0
Ubicación
00 Qan[T]
Mensajes
91
Reacciones
0
Puntos
0
Ubicación
En medio de la infección del "F-virus" 0.o
Aquí les traígo un script que no me toco ver por el foro.

-Nombre del script: Ni idea, yo lo llamo locación.
-Versión del script: No dice.
-RPG Maker: XP

Instrucciones:
Hagan una nueva página de script arriba de Main, que se llame Buwaro's kool!
Pongan el script ahí!

Por cierto, el script no es mío!

$data_mapinfos = load_data('Data/MapInfos.rxdata')

class Window_Steps

def refresh
contents.clear
contents.font.color = system_color
contents.draw_text(4, 0, 120, 32, 'Location')
contents.font.color = normal_color
name = $data_mapinfos[$game_map.map_id].name
contents.draw_text(0, 32, 128, 32, name)

end
end
Les daré una breve introducción:
No es odioso que se muestren los pasos en el Menu???
Digo, a quién le importa cuantos pasos a dado!?
Lo que este script hace, es mostrarte el nombre del mapa en el que te encuentras, en vez de mostrarte los pasos que haz dado!!!

Screen shots:
El lugar.
Pantalla.jpg


Sin el script.
Sinscript.jpg


Con el script.
Conscript.jpg


Espero les sea de utilidad!!!
 
Última edición:
Mensajes
197
Reacciones
0
Puntos
0
-Nombre Del Script: [RPGVX]MODE 7
-Version Del Script:1.0
-Rpg Maker:VX

Este script creo que no tiene explicacion...
21605047ar6.png

la imagen, lo dice todo. xDD

El script es muy largo...
aqui dejo la demo:
http://www.mediafire.com/?mfnyzcittwt

apisonadorazf2.png

Mirror
http://rapidshare.com/files/180834830/Mode7_VX.rar.html
http://www.zshare.net/download/53817113e9a78119/
http://depositfiles.com/es/files/ebf7iyjxf
http://www.badongo.com/file/12796485

Credito- desconocido

al abrirlo no me va, me da error >.<
 
Mensajes
9.007
Reacciones
224
Puntos
0
Ubicación
00 Qan[T]
al abrirlo no me va, me da error >.<

que te dice el error?

pd- EDITA, para no hacer un chat


----------------------------------------------------------------------------------------------------------------

-Nombre Del Script: Menú Final Fantasy IX
-Version Del Script:no dice
-Rpg Maker:VX


Descripción:
Cambia el menú por defecto del RMVX por uno muy similar al del videojuego Final Fantasy IX (PlayStation). Queda mejor con la fuente 'Centaur'.

Screen:
delete-34.png


Recursos Necesarios:
En Graphics/Pictures:
FF9_MenuBar.png

Timer.png

Arrow.png
Opcionalmente, en Graphics/System puedes colocar este windowskin del FFIX para usarlo durante el juego:
Window-1.png


Script:

Código:
#============================================================================= * * * * * * * * 
# * * * * * * * * * * *Menú Final Fantasy IX de BigEd781
# * * * Créditos a PainHurt (rpgmakervx.net) por la mayoría de los gráficos
#=============================================================================

module FF9_Config
 *# Pon true para que el modo FFIX aparezca en todas las ventanas y textos
 *USE_FOR_ALL = true
 *
 *# El nombre de la fuente usada en el menú *
 *# Usa 'Font.default_name' para la fuente por defecto. Prueba 'Centaur' 
 *# para una fuente más pequeña que queda mejor.
 *DEFAULT_FONT = Font.default_name

 *# Hace que las ventana de elecciones sean algo menos amplias, queda mejor
 *USE_SMART_COMMAND_WINDOW = true
 *
 *# La ID del icono de oro para su parte del menú, 194 por defecto.
 *GOLD_ICON_ID = 194
end

if FF9_Config::USE_FOR_ALL * * 
 *
 *Font.default_name = FF9_Config::DEFAULT_FONT
 *
 *class Window_Base < Window
 * *
 * *alias :eds_pre_ff9_menu_base_initialize :initialize
 * *def initialize(x, y, width, height)
 * * *eds_pre_ff9_menu_base_initialize(x, y, width, height) * * *
 * * *self.back_opacity = 255
 * *end
 * *
 *end
 *
end

class Window_TimeGold < Window_Base *
 * *
 *def initialize(x, y) *
 * *width = find_window_width("9999999")
 * *width = 140 if width < 140
 * *super(x, y, width, WLH + 58)
 * *self.back_opacity = 255
 * *self.contents.font.name = FF9_Config::DEFAULT_FONT
 * *@time_icon = Cache.picture('Timer') *
 * *@intern_frame_count = 0
 * *refresh
 *end
 *
 *def draw_time
 * *sec = Graphics.frame_count / 60
 * *min = Graphics.frame_count / 3600
 * *hrs = Graphics.frame_count / 216000 * *
 * *self.contents.font.color = Color.new(255, 255, 255) * *
 * *time = "%02d:%02d:%02d" % [hrs, min, sec]
 * *self.contents.draw_text(0, 0, self.contents.width, WLH, time, 2) * *
 *end *
 *
 *def refresh
 * *self.contents.clear
 * *self.contents.blt(0, 0, @time_icon, @time_icon.rect)
 * *draw_icon(FF9_Config::GOLD_ICON_ID, 2, WLH) * 
 * *draw_currency_value($game_party.gold, 0, WLH, self.contents.width)
 * *draw_time
 *end
 *
 *def update
 * *super 
 * *@intern_frame_count += 1
 * *return if (@intern_frame_count % 60) != 0 * * * * *
 * *refresh
 *end
 *
 *def find_window_width(text) * * * * * * *
 * *return Bitmap.new(544, 416).text_size(text).width + 80
 *end
 *
end

class Window_MenuLocation < Window_Base
 *
 *def initialize(x, y)
 * *@map_name = load_data("Data/MapInfos.rvdata")[$game_map.map_id].name
 * *width = find_window_width(@map_name)
 * *super(x, y, width, WLH + 32) * *
 * *self.contents.font.name = FF9_Config::DEFAULT_FONT
 * *self.back_opacity = 255
 * *refresh
 *end
 *
 *def refresh
 * *self.contents.clear * *
 * *self.contents.draw_text(0, 0, self.contents.width, WLH, *@map_name, 1)
 *end
 *
 *def find_window_width(text) * * * * * * *
 * *return Bitmap.new(544, 416).text_size(text).width + 48
 *end
 *
end

class Window_Command < Window_Selectable
 *
 *alias :eds_pre_ff9_menu_win_command_init :initialize
 *def initialize(width, commands, column_max = 1, row_max = 0, spacing = 32) * 
 * *@font_name = Font.default_name
 * *width = find_window_width(commands) if FF9_Config::USE_SMART_COMMAND_WINDOW
 * *eds_pre_ff9_menu_win_command_init(width, commands, column_max, row_max, spacing) 
 *end
 *
 *def find_window_width(texts) * * *
 * *long = '' * *
 * *texts.each { |line| long = line if line.size > long.size } * * * * * * * * * *
 * *return Bitmap.new(544, 416).text_size(long).width + 48
 *end
 *#--------------------------------------------------------------------------
 *# * OVERWRITTEN
 *#--------------------------------------------------------------------------
 *def refresh
 * *self.contents.clear * *
 * *self.contents.font.name = @font_name
 * *for i in 0...@item_max
 * * *draw_item(i)
 * *end
 *end
 *
 *def font_name=(name)
 * *@font_name = name * *
 *end
 *
end

class Window_MenuStatus < Window_Selectable
 * *
 *#--------------------------------------------------------------------------
 *# * OVERWRITTEN
 *#--------------------------------------------------------------------------
 *def initialize(x, y)
 * *super(x, y, 452, 352) * *
 * *@bg_image = Cache.picture('FF9_MenuBar') * 
 * *@arrow_image = Cache.picture('Arrow')
 * *@arrow_sprite = Sprite.new
 * *@arrow_sprite.bitmap = Bitmap.new(45, 38) *#7 píxeles más grande en 'h' para animación * * *
 * *@arrow_sprite.y = 52 *
 * *@arrow_sprite.z = 999 * *
 * *@sprite_last_draw_x = 0
 * *@sprite_inc_x = 1
 * *@intern_frame_count = 0 * *
 * *self.contents.font.name = FF9_Config::DEFAULT_FONT
 * *self.opacity = 0 * *
 * *self.z = 99 * *
 * *refresh
 * *self.active = false
 * *self.index = -1
 *end
 *#--------------------------------------------------------------------------
 *# * OVERWRITTEN
 *#--------------------------------------------------------------------------
 *def refresh * *
 * *self.contents.clear
 * *@item_max = $game_party.members.size
 * *for actor in $game_party.members * * *
 * * *x = 104
 * * *y = actor.index * 80 * * *
 * * *y_offset = 6
 * * *draw_background_window(y)
 * * *draw_actor_face(actor, 19, y + 4, 73) * * *
 * * *draw_actor_name(actor, x, y + y_offset)
 * * *draw_actor_class(actor, x + 125, y + y_offset)
 * * *draw_actor_level(actor, x, y + WLH * 1)
 * * *draw_actor_state(actor, x, y + WLH * 2)
 * * *draw_actor_hp(actor, x, ((y) + (WLH * 2) - 5))
 * * *draw_actor_mp(actor, x + 125, ((y) + (WLH * 2) - 5)) * *
 * *end
 *end * 
 *#--------------------------------------------------------------------------
 *# * OVERWRITTEN
 *#--------------------------------------------------------------------------
 *def update_cursor * * * * * * * 
 * *if @index < 0 * * * * * * *
 * * *@arrow_sprite.bitmap.clear
 * * *return
 * *end
 * *@intern_frame_count += 1
 * *return if (@intern_frame_count % 5) != 0
 * *if @sprite_last_draw_x == 7
 * * *@sprite_inc_x = -1
 * *elsif @sprite_last_draw_x == 0
 * * *@sprite_inc_x = 1
 * *end
 * *@arrow_sprite.bitmap.clear
 * *@arrow_sprite.y = (@index * 80) + 52
 * *x = @sprite_last_draw_x + @sprite_inc_x * *
 * *@sprite_last_draw_x = x
 * *@arrow_sprite.bitmap.blt(x, 0, @arrow_image, @arrow_image.rect) * *
 *end
 *
 *def draw_background_window( y )
 * *self.contents.blt(0, y, @bg_image, @bg_image.rect) * *
 *end *
 *
 *alias :eds_pre_ff9_win_stat_dispose :dispose
 *def dispose
 * *eds_pre_ff9_win_stat_dispose
 * *@arrow_sprite.dispose
 *end
 *
end

class Scene_Menu
 * * *
 *#--------------------------------------------------------------------------
 *# * Create Command Window
 *#--------------------------------------------------------------------------
 *alias :eds_old_pre_ff9_create_command_window :create_command_window
 *def create_command_window
 * *eds_old_pre_ff9_create_command_window * *
 * *@command_window.font_name = FF9_Config::DEFAULT_FONT
 * *@command_window.x = 528 - @command_window.width
 * *@command_window.y = 16
 * *@command_window.back_opacity = 255
 *end
 *#--------------------------------------------------------------------------
 *# * OVERWRITTEN
 *#--------------------------------------------------------------------------
 *def start
 * *super
 * *create_menu_background
 * *create_command_window
 * *@gold_window = Window_TimeGold.new(372, 360)
 * *@gold_window.y -= @gold_window.height
 * *@gold_window.x = 528 - @gold_window.width
 * *@status_window = Window_MenuStatus.new(0, 12)
 * *@location_window = Window_MenuLocation.new(0, 0)
 * *@location_window.x = 528 - @location_window.width *
 * *@location_window.y = 416 - @location_window.height *
 *end
 *
 *#--------------------------------------------------------------------------
 *# * Termination Processing
 *#--------------------------------------------------------------------------
 *alias :eds_pre_ff9_menu_scene_menu_terminate :terminate
 *def terminate
 * *eds_pre_ff9_menu_scene_menu_terminate
 * *@location_window.dispose
 *end
 *
end

Instrucciones:
Pon el script en la sección Materiales, arriba del todo. Es para asegurarse que no queda bajo ningún otro que modifique el menú, por si acaso.
Puedes modificar alguna cosilla en el script, está marcado, pero no es necesario.

Créditos:
Script creado por BigEd781.
Recursos gráficos creados por PainHurt
 
Última edición:
Mensajes
9.007
Reacciones
224
Puntos
0
Ubicación
00 Qan[T]
El error dice esto cuando intentas abrir el demo:



Y esto te dice si lo queres abrir como proyecto en el VX:


no captaste mi mensaje, cierto?

en fin...

necesitas la version RGSS202E.dll del RPG MAKER VX...

aqui esta:
http://www.megaupload.com/?d=RTMJYLZT

me dices si te funciona...


tienes mucas dudas

...


Edito: Ok, ya descubri mi problema.................no sabía que había más versiones XD, por eso no captaba, muchisimas gracias.

problema resuelto xD
 
Última edición:
Estado
Cerrado para nuevas respuestas
Arriba Pie