Mundo Maker
¡Bienvenid@ a Mundo Maker!

¿Quieres aprender todo sobre el RPG Maker?



Regístrate y forma parte de Mundo Maker.

[XP]Arena de Batalla

Ver el tema anterior Ver el tema siguiente Ir abajo

RPG Maker XP [XP]Arena de Batalla

Mensaje por AsFzKakarotto el 2018-01-05, 20:04

Autores: ForeverZer0 http://www.gdunlimited.net/forums/topic/7028-battle-arena/
Versión: 1.0
Mejoras: AsFzkakarotto (Como no es mio no pido créditos)

Introducción:

Es idea bastante simple, te permitirá crear fácilmente un sistema Battle Arena (muy parecido al de Final Fantasy VI). El jugador puede apostar elementos, armas y armaduras y luego luchar en la arena contra diferentes enemigos y recibir premios si ganan. Es un sistema de "ganador se lo lleva todo", donde el ganador puede mantener su apuesta original y la apuesta del enemigo si sale victorioso. Si pierden, pierden su apuesta original.


Características

Se puede configurar fácilmente para la mayoría de los sistemas de batalla
Resultados totalmente configurables para cada elemento, arma y armadura
Permite recompensas de 'una sola vez' para apuestas específicas
Fácil de configurar, y utiliza solo dos llamadas de script en el juego para usar
Registra las ganancias / pérdidas en las variables del juego para acceder fácilmente a las estadísticas





Aquí el Script e Instrucciones:

Código:
=begin
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
 Battle Arena  
 Author: ForeverZer0
 Date: 4.28.2010
 Version: 1.0                   Traducción Español y Mejoras:  AsFz Kakarotto
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:

  Explicación:  
  
 La idea es relativamente simple.
 Permite al Jugador Apostar un Artículo, Arma o Armadura.
 Lucha contra un enemigo para recibir un artículo diferente a cambio.
 Mismo sistema usado en Final Fantasy VI para SNES. El Ganador, consigue
 guardar su propio artículo apostado y conseguir el artículo del enemigo.
 El Perdedor, perderá el Artículo que Apostó.

  Instrucciones:

 - Defina más abajo los enemigos y articulos que desees como preferente.
   Llamar el script de la siguiente forma para abrir el menu principal de
   retos, apuestas y recompensas:

   $scene = Scene_BattleArena.new
  
    Importante:
    Este llamado de Script posee una pequeña falla en la cual borrará el
    proximo comando usado, ejemplo el de Mostrar mensaje....
    Para solucionar el pequeño error usar despues del llamado de script
    lo siguiente:
    Usar el comando "Esperar" con 1 Frame  (Este comando será borrado)
    Y luego usar todos los siguientes comandos deseados...

# ==============================================================================
 - Llamar el Script de la siguiente forma para luchar directamente con
   los enemigos escojidos con el menu de retos, apuestas y recompensas:

   $game_temp.arena_battle_call(map,x,y)    

 - Los valores en () será donde el jugador será transferido después de ganar o
   perder la batalla. Si usted no quiere que ellos se muevan, sólo no incluya
   el (). En donde:
   (map = ID del mapa, x = Cordenada X del mapa, y = Cordenada Y del mapa)
  
# ==============================================================================
 - Si has Activado el menu de recompensas y has elegido que vas a Apostar.
   Con el siguiente Script tu podrás cancelar o borrar ese Duelo.
  
   loop {Graphics.update; Input.update; update; break if $scene != self}
    $game_temp.arena_battle = false
    $game_temp.arena_data.clear

    Importante:
    Este llamado de Script posee una pequeña falla en la cual borrará el
    proximo comando usado, ejemplo el de Mostrar mensaje....
    Para solucionar el pequeño error, usar despues del llamado de script
    lo siguiente:
    Usar el comando "Esperar" con 1 Frame   (Este comando no será borrado)
    Usar otro comando "Esperar" con 1 Frame  (Este comando será borrado)
    Y luego usar todos los siguientes comandos deseados...
    
# ==============================================================================
 - Ganar un artículo de recompenza sin luchar...
   Simplemente usar el llamado de script con el siguiente codigo:

   id = $game_temp.arena_data[1].id
      case $game_temp.arena_data[1]
      when RPG::Item then $game_party.gain_item(id, 1)
      when RPG::Weapon then $game_party.gain_weapon(id, 1)
      when RPG::Armor then $game_party.gain_armor(id, 1)
      end
  
   De lo contrario, para perder un artículo de recompenza sin luchar
   simplemente cambiar los 3 ultimos 1 por -1, ejemplo:
  
   id = $game_temp.arena_data[1].id
      case $game_temp.arena_data[1]
      when RPG::Item then $game_party.gain_item(id, -1)
      when RPG::Weapon then $game_party.gain_weapon(id, -1)
      when RPG::Armor then $game_party.gain_armor(id, -1)
      end
    
  Importante:
    Aclarar que estos llamados de script se pueden usar en cualquier
    momento del juego siempre y cuando se haya declarado antes una
    batalla, para que así el comando pueda comprender que elemento está
    como apuesta y tambien como recompenza.
    Estos script no harán ningun cambio si de lo contrario no se
    ha definido una batalla o se elimino con el script correspondiente
    para borrar un duelo definido.
    
# ==============================================================================
 - Perder un artículo apostado sin luchar...
   Simplemente usar el llamado de script con el siguiente codigo:

   id = $game_temp.arena_data[0].id
      case $game_temp.arena_data[0]
      when RPG::Item then $game_party.lose_item(id, 1)
      when RPG::Weapon then $game_party.lose_weapon(id, 1)
      when RPG::Armor then $game_party.lose_armor(id, 1)
  
   De lo contrario, para ganar un artículo apostado sin luchar
   simplemente cambiar los 3 ultimos 1 por -1, ejemplo:
  
   id = $game_temp.arena_data[0].id
      case $game_temp.arena_data[0]
      when RPG::Item then $game_party.lose_item(id, -1)
      when RPG::Weapon then $game_party.lose_weapon(id, -1)
      when RPG::Armor then $game_party.lose_armor(id, -1)

  Importante:
    Aclarar que estos llamados de script se pueden usar en cualquier
    momento del juego siempre y cuando se haya declarado antes una
    batalla, para que así el comando pueda comprender que elemento está
    como apuesta y tambien como recompenza.
    Estos script no harán ningun cambio si de lo contrario no se
    ha definido una batalla o se elimino con el script correspondiente
    para borrar un duelo definido.
    
# ==============================================================================
  - Cambiar los resultados de victoria o derrota.
    Simplemente usar el siguiente llamado de script:
    
    Para Ganados:
    $game_variables[Zer0_CFG::WIN_VARIABLE]
    
    Para Perdidos:
    $game_variables[Zer0_CFG::LOSS_VARIABLE]
    
    seguido de esto puedes realizar la formula matematica
    para cambiar el resultado a tu gusto, ejemplo:

    $game_variables[Zer0_CFG::WIN_VARIABLE] += 1

    (Aumentará el resultado de batallas ganadas a + 1)
    
    
# ==============================================================================

 - Para colocar en Condiciones y efectos/ Llamado de Script:
      
   $game_temp.arena_battle

   Esto permite comprovar si has activado un duelo con el menu de retos,
   apuestas y recompensas.
   Si marcas "Añadir Exepción" en "Condiciones y efectos", podrás colocar
   comandos que sucederán al NO haber declarado un duelo con el menu.
 
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
=end

module Zer0_CFG
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
#                         COMIENZO DE CONFIGURACIÓN
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:

# Las IDs de las variables que registrarán el valor de sus victorias y derrotas.

  WIN_VARIABLE = 1      # ID de Variable para registrar Batallas Ganadas
  LOSS_VARIABLE = 2     # ID de Variable para registrar Batallas Perdidas
  STATUS_SWITCH = 50    # ID de Interruptor para indicar si has ganado o no
                        # true = Ganaste / false = Perdiste
  
  
# Aquí Coloque las IDs de cualquier Objetos/Armas/Armaduras que el jugador
#  no podrá apostar.  
# El Articulo No se presentará como una opción en la ventana.

  NO_BET_ITEMS = []                         #Para Objetos
  NO_BET_WEAPONS = []                       #Para Armas
  NO_BET_ARMORS = []                        #Para Armaduras
  
# Aquí Coloque las IDs de cualquier Objetos/Armas/Armaduras que el jugador
# recibirá como premio sólo una vez. Después de eso, si ellos re-apostarán
# el mismo artículo de nuevo, se retornará a la apuesta por defecto como premio.
  
  ONLY_ONCE_ITEMS = []                      #Para Objetos
  ONLY_ONCE_WEAPONS = []                    #Para Armas
  ONLY_ONCE_ARMORS = []                     #Para Armaduras
  

  
#-------------------------------------------------------------------------------
#                Comienza la Base de datos De Arena de Batalla
#-------------------------------------------------------------------------------
#
# Hay 3 secciones que necesitarán configurar; uno cada uno para los
# Artículos, Armas y Armaduras. Prepare cada sección a su gusto:
#
#         when ID then return [TROOP, REWARD_TYPE, REWARD_ID]
#
#   ID       - ID del Artículo, Arma, o Armadura que el Jugador deberá Apostar.
#   TROOP    - ID de el Grupo enemigo que usted luchará.
#
#   REWARD_TYPE - 'El tipo' de Premio que se dará al ganador.
#                 0 = Objetos
#                 1 = Armas
#                 2 = Armaduras
#   REWARD_ID   - ID de el Artículo (Dependiendo del tipo) el cual se Ganará
#                 este Árticulo simula ser dueño de la tropa enemiga.
#
#   Aquí un Ejemplo:
#
#     when 5 then return [4, 2, 34]  
#                        (pretendamos que está en la Base de datos del Artículo)
#
# Esto significaría que si el jugador escogiera apostar el Artículo con
# la ID(5), El grupo enemigo con ID(4) estaría interesado en ganar y si ellos
# ganarán, Recivirán tu Artículo de ID (5) y La armadura con ID(34) que ellos
# acaban de apostar. (es una Armadura porque el TIPO de Artículo es 2).
#
# De lo contrario si ganas tú, obtendras El Artículo que apostaste ID(5) y
# La Armadura ID(34) Que los enemigos Apostarón.
# (Recuerda que es una Armadura porque el TIPO de Artículo es 2).
#
#-------------------------------------------------------------------------------
  
# Ésta será la configuración por defecto para cualquier Objeto/Arma/Armadura
# que el juagador deviera apostar y que no ha sido definido en este Script
# [TROOP, REWARD_TYPE, REWARD_ID].

  DEFAULT_REWARD = [1, 0, 1]

# ==============================================================================
#                                                         [INFERIOR NO EDITABLE]
# ==============================================================================
  
  def self.wagers(item)
    if item.is_a?(RPG::Item)
      return DEFAULT_REWARD if $game_system.arena_one_time[0].include?(item.id)
      case item.id
#-------------------------------------------------------------------------------
# * OBJETOS que quieres apostar de la Base de datos.         [INFERIOR EDITABLE]
#-------------------------------------------------------------------------------
    
      when 1 then return [1, 0, 2]
      when 2 then return [3, 0, 3]
      when 3 then return [5, 0, 4]
      when 4 then return [8, 1, 1]
      when 5 then return [9, 2, 1]
        
#-------------------------------------------------------------------------------
# * Fin de la apuesta de objetos                          [INFERIOR NO EDITABLE]
#-------------------------------------------------------------------------------
      end
    elsif item.is_a?(RPG::Weapon)
      return DEFAULT_REWARD if $game_system.arena_one_time[1].include?(item.id)
      case item.id
#-------------------------------------------------------------------------------
# * ARMAS que quieres apostar de la Base de datos.           [INFERIOR EDITABLE]
#-------------------------------------------------------------------------------

      when 1 then return [1, 2, 1]
      when 2 then return [12, 1, 3]
      when 3 then return [20, 1, 5]
      when 4 then return [15, 2, 4]
      when 5 then return [25, 0, 10]
        
#-------------------------------------------------------------------------------
# * Fin de la apuesta de objetos                          [INFERIOR NO EDITABLE]
#-------------------------------------------------------------------------------
      end
    elsif item.is_a?(RPG::Armor)
      return DEFAULT_REWARD if $game_system.arena_one_time[2].include?(item.id)
      case item.id
#-------------------------------------------------------------------------------
# * ARMADURAS que quieres apostar de la Base de datos.       [INFERIOR EDITABLE]
#-------------------------------------------------------------------------------
      
      when 1 then return [1, 1, 1]
      when 2 then return [5, 2, 3]
      when 3 then return [13, 2, 5]
      when 4 then return [10, 1, 5]
      when 5 then return [21, 2, 10]
# Depende de Variables 17,18,19 y 20:
      when $game_variables[17] then return [$game_variables[18], $game_variables[19], $game_variables[20]]
        
        
#-------------------------------------------------------------------------------
# * Fin de la apuesta de armaduras                        [INFERIOR NO EDITABLE]
#-------------------------------------------------------------------------------

#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
#                    FIN DE LA CONFIGURACIONES EDITABLES
#:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:=:
      end
    end
    return DEFAULT_REWARD
  end
end

#-------------------------------------------------------------------------------
# ** Game_System
#-------------------------------------------------------------------------------

class Game_System
  
  attr_accessor :arena_one_time   # Retains data on all the ONCE_ONLY bets
  
  alias zer0_arena_once_only_init initialize
  def initialize
    zer0_arena_once_only_init
    @arena_one_time = [[],[],[]]
  end
end

#-------------------------------------------------------------------------------
# ** Game_Temp
#-------------------------------------------------------------------------------

class Game_Temp
  
  attr_accessor :arena_data      # Holds info for bet, reward, battler, etc
  attr_accessor :arena_battle    # Arena Battle flag
  attr_accessor :party_memory    # Memorizes party pre-battle to return after
  
  alias zer0_battle_arena_temp_init initialize
  def initialize
    zer0_battle_arena_temp_init
    @arena_data = []
    @party_memory = []
    @arena_battle = false
  end
  
  def arena_battle_call(map_id=$game_map.map_id, x=$game_player.x , y=$game_player.y)
    @party_memory.clear
    $game_party.actors.each {|actor| @party_memory.push(actor.id)}
    $game_party.actors.clear
    $game_party.add_actor(@arena_data[2])
    @battle_calling = true
    @battle_can_escape = false
    @battle_can_lose = true
    @battle_proc = nil
    @player_new_map_id = map_id
    @player_new_x = x
    @player_new_y = y
    @player_new_direction = 2
    Graphics.freeze
    @player_transferring = true
  end
end

#-------------------------------------------------------------------------------
# ** Scene_BattleArena
#-------------------------------------------------------------------------------

class Scene_BattleArena

  def main
    @help_window = Window_Help.new
    @item_window = Window_ItemBet.new
    @item_window.help_window = @help_window
    @status_window = Window_ArenaStatus.new
    @header1 = Window_Base.new(320, 64, 320, 64)
    @header1.contents = Bitmap.new(288, 32)
    @header1.contents.draw_text(0, 0, 288, 32, 'Cual es tu Apuesta?', 1)
    @header2 = Window_Base.new(176, 128, 288, 64)
    @header2.contents = Bitmap.new(256, 32)
    @header2.contents.draw_text(0, 0, 256, 32, '¿Quién batallará?', 1)
    @header2.z = 5000
    @actor_window = Window_BattlerSelect.new
    @actor_window.active = @actor_window.visible = @header2.visible = false
    Graphics.transition
    loop {Graphics.update; Input.update; update; break if $scene != self}
    [@help_window, @item_window, @status_window, @header1, @header2,
     @actor_window].each {|window| window.dispose}
  end
  
  def update
    [@help_window, @status_window, @item_window,
      @actor_window].each {|window| window.update}
    if @item_window.active
       @status_window.data = @item_window.item
      if Input.trigger?(Input::B)
        $game_system.se_play($data_system.buzzer_se)
      elsif Input.trigger?(Input::C)
        $game_system.se_play($data_system.decision_se)
        @data = Zer0_CFG.wagers(@item_window.item)
        @actor_window.active = @actor_window.visible = @header2.visible = true
        @item_window.active = false
        return
      end
    elsif @actor_window.active
      if Input.trigger?(Input::B)
        $game_system.se_play($data_system.cancel_se)
        @actor_window.active = @actor_window.visible = @header2.visible = false
        @item_window.active = true
        return
      elsif Input.trigger?(Input::C)
        if $game_party.actors[@actor_window.index].dead?
          $game_system.se_play($data_system.buzzer_se)
          return
        end
        $game_system.se_play($data_system.decision_se)
        if $data_troops[@data[0]] != nil
          $game_temp.battle_troop_id = @data[0]
          $game_temp.arena_data[2] = $game_party.actors[@actor_window.index].id
          $game_temp.arena_data[0] = @item_window.item
          $game_temp.arena_data[1] = case @data[1]
          when 0 then $data_items[@data[2]]
          when 1 then $data_weapons[@data[2]]
          when 2 then $data_armors[@data[2]]
          end
          $game_temp.arena_battle = true
          $scene = Scene_Map.new
        end  
      end
    end
  end
end

#-------------------------------------------------------------------------------
# ** Scene_ArenaResult
#-------------------------------------------------------------------------------

class Scene_ArenaResult
  
  def initialize(battle_result)
    @result = battle_result
  end
  
  def main
    @map = Spriteset_Map.new
    $game_party.actors[0].hp = 1 if @result != 0
    $game_party.actors.clear
    $game_temp.party_memory.each_index {|i|
      $game_party.add_actor($game_temp.party_memory[i])}
    @message_window = Window_Message.new
    Graphics.transition
    bet_item = $game_temp.arena_data[0]
    case bet_item
    when RPG::Item
      if Zer0_CFG::ONLY_ONCE_ITEMS.include?(bet_item.id)
        unless $game_system.arena_one_time[0].include?(bet_item.id)
          $game_system.arena_one_time[0].push(bet_item.id)
        end
      end
    when RPG::Weapon
      if Zer0_CFG::ONLY_ONCE_WEAPONS.include?(bet_item.id)
        unless $game_system.arena_one_time[1].include?(bet_item.id)
          $game_system.arena_one_time[1].push(bet_item.id)
        end
      end
    when RPG::Armor
      if Zer0_CFG::ONLY_ONCE_ARMORS.include?(bet_item.id)
        unless $game_system.arena_one_time[2].include?(bet_item.id)
        $game_system.arena_one_time[2].push(bet_item.id)
        end
      end
    end
#===============================================================================
#======= Comandos que suceden al ganar o perder una batalla de apustas =========
#===============================================================================
    if @result == 0
      Audio.se_play('Audio/SE/060-Cheer01', 80, 100)
      $game_variables[Zer0_CFG::WIN_VARIABLE] += 1
      $game_switches[Zer0_CFG::STATUS_SWITCH] = true
      reward = $game_temp.arena_data[1].name
      text = "Congratulations!\n" + 'Acabas de Ganar ' + reward + '!'
    else
      $game_variables[Zer0_CFG::LOSS_VARIABLE] += 1
      $game_switches[Zer0_CFG::STATUS_SWITCH] = false
      text = 'Has Perdido...'
    end
    $game_temp.message_text = text
    loop {Graphics.update; Input.update; update; break if $scene != self}
    $game_temp.arena_battle = false
    $scene = Scene_Map.new
    [@map, @message_window].each {|sprite| sprite.dispose}
  end
  
  def update
    [@map, @message_window].each {|sprite| sprite.update}
    if Input.trigger?(Input::C)
      $scene = Scene_Map.new
    end
  end
end

#===============================================================================
# ** Scene_Battle
#===============================================================================

class Scene_Battle
  
  alias zer0_battle_arena_result battle_end
  def battle_end(result)
    # This will just redirect the scene to the Arena Result screen instead
    # of Scene_Map if the arena flag is present
    zer0_battle_arena_result(result)
    if $game_temp.arena_battle
      $scene = Scene_ArenaResult.new(result)
    end
  end
end

#-------------------------------------------------------------------------------
# ** Window_ArenaStatus
#-------------------------------------------------------------------------------

class Window_ArenaStatus < Window_Base
  
  def initialize
    super(320, 128, 320, 352)
    self.contents = Bitmap.new(width - 32, height - 32)
    @data = nil
    refresh
  end
  
  def refresh
    self.contents.clear
    return if @data == nil
    @data = Zer0_CFG.wagers(@data)
    self.contents.font.color = system_color
    self.contents.draw_text(4, 0, 288, 32, 'Enemigos:')
    self.contents.draw_text(4, 256, 288, 32, 'Recompensa:')
    self.contents.font.color = normal_color
    member = $data_troops[@data[0]].members
    names = []
    member.each_index {|i| names[i] = $data_enemies[member[i].enemy_id].name
      y = (i * 27) + 32
      self.contents.draw_text(4, y, 288, 32, names[i]) if y < 256}  
    case @data[1]
    when 0
      reward = $data_items[@data[2]].name
      icon = $data_items[@data[2]].icon_name
    when 1
      reward = $data_weapons[@data[2]].name
      icon = $data_weapons[@data[2]].icon_name
    when 2
      reward = $data_armors[@data[2]].name
      icon = $data_armors[@data[2]].icon_name
    end
    self.contents.draw_text(32, 288, 288, 32, reward)
    rect = Rect.new(x, y, self.width - 32, 32)
    self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
    self.contents.blt(4, 292, RPG::Cache.icon(icon), Rect.new(0, 0, 24, 24))
  end
  
  def data=(data)
    if @data != data
      @data = data
      refresh
    end
  end
end

#-------------------------------------------------------------------------------
# ** Window_ItemBet
#-------------------------------------------------------------------------------

class Window_ItemBet < Window_Selectable

  def initialize
    super(0, 64, 320, 416)
    @column_max, self.index = 1, 0
    refresh
  end

  def item
    return @data[self.index]
  end

  def refresh
    if self.contents != nil
      self.contents.dispose
      self.contents = nil
    end
    @data = []
    (1...$data_items.size).each {|i|
      if $game_party.item_number(i) > 0
        unless Zer0_CFG::NO_BET_ITEMS.include?(i)
          @data.push($data_items[i])
        end
      end
    }
    (1...$data_weapons.size).each {|i|
      if $game_party.weapon_number(i) > 0
        unless Zer0_CFG::NO_BET_WEAPONS.include?(i)
          @data.push($data_weapons[i])
        end
      end
    }
    (1...$data_armors.size).each {|i|
      if $game_party.armor_number(i) > 0
        unless Zer0_CFG::NO_BET_ARMORS.include?(i)
          @data.push($data_armors[i])
        end
      end
    }
    @item_max = @data.size
    if @item_max > 0
      self.contents = Bitmap.new(width - 32, row_max * 32)
      (0...@item_max).each {|i| draw_item(i)}
    end
  end

  def draw_item(index)
    item = @data[index]
    number = case item
    when RPG::Item then $game_party.item_number(item.id)
    when RPG::Weapon then $game_party.weapon_number(item.id)
    when RPG::Armor then $game_party.armor_number(item.id)
    end
    x = 4
    y = index * 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)
    opacity = self.contents.font.color == normal_color ? 255 : 128
    self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
    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 update_help
    @help_window.set_text(self.item == nil ? '' : self.item.description)
  end
end

#-------------------------------------------------------------------------------
# ** Window_BattlerSelect
#-------------------------------------------------------------------------------

class Window_BattlerSelect < Window_Selectable
  
  def initialize
    w = ($game_party.actors.size * 64) + 32
    x = (640 - w) / 2
    super(x, 192, w, 96)
    self.contents = Bitmap.new(width - 32, height - 32)
    @row_max, self.index, self.z = 1, 0, 5000
    @item_max = @column_max = $game_party.actors.size
    refresh
  end
  
  def refresh
    $game_party.actors.each_index {|i|
    x = 32 + i * 64
    self.draw_actor_graphic($game_party.actors[i], x, 64)}
  end
  
  def update_cursor_rect
    cursor_width = 48
    x = @index * 64 + 8
    y = @index / @column_max * 32 - self.oy
    self.cursor_rect.set(x, y, cursor_width, 64)
  end
end

Aquí la  Demostración.
avatar
AsFzKakarotto
Soñador
Soñador

0/3

Créditos 307

Gracias : 68

Volver arriba Ir abajo

Ver el tema anterior Ver el tema siguiente Volver arriba


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