Mundo Maker
¡Bienvenid@ a Mundo Maker!

¿Quieres aprender todo sobre el RPG Maker?



Regístrate y forma parte de Mundo Maker.

[RMXP] Menu de Items estilo Dragon Quest VIII

Ver el tema anterior Ver el tema siguiente Ir abajo

RPG Maker XP [RMXP] Menu de Items estilo Dragon Quest VIII

Mensaje por AsFzKakarotto el 2018-03-29, 16:33

Bueno este sistema permite ordenar por categoría sus artículos con la apariencia que tiene el inventario del juego
Dragon Quest VIII de la Play Station 2. En lo personal no lo he visto en el foro por lo cual lo comparto aquí con usd.

Autor: Crhonos



Script (Colocar en el mismo orden arriba de el script main)

Crhonos Base
Código:
#==================================================================
#Windows Base Crhonos
#As chances deste "modulo" dar erro com outros eh de menos de 10%, ou seja
#não atrapalha outros scripts
#======================================================================
  module RPG::Cache

  def self.menu(filename)
    self.load_bitmap("Graphics/Menu/", filename.to_s, 0)
  end
  
end
#Obs: A dificuldade dos outros scripts esta aki....

#===================================================================
#Parte 1
#Status
#===================================================================

class Bitmap
end
  # @ Draw line
  #-----------------------------------------------------------------------------
  def draw_line(start_x, start_y, end_x, end_y, start_color, width = 1,
                end_color = start_color)
    distance = (start_x - end_x).abs + (start_y - end_y).abs
    if end_color == start_color
      for i in 1..distance
        x = (start_x + 1.0 * (end_x - start_x) * i / distance).to_i
        y = (start_y + 1.0 * (end_y - start_y) * i / distance).to_i
        if width == 1
          self.set_pixel(x, y, start_color)
        else
          self.fill_rect(x, y, width, width, start_color)
        end
      end
    else
      for i in 1..distance
        x = (start_x + 1.0 * (end_x - start_x) * i / distance).to_i
        y = (start_y + 1.0 * (end_y - start_y) * i / distance).to_i
        r = start_color.red   * (distance - i) / distance + end_color.red   *
            i / distance
        g = start_color.green * (distance - i) / distance + end_color.green *
            i / distance
        b = start_color.blue  * (distance - i) / distance + end_color.blue  *
            i / distance
        a = start_color.alpha * (distance - i) / distance + end_color.alpha *
            i / distance
        if width == 1
          self.set_pixel(x, y, Color.new(r, g, b, a))
        else
          self.fill_rect(x, y, width, width, Color.new(r, g, b, a))
        end
      end
    end
  end

class Window_Base < Window
  
  
     def draw_actor_face(actor, x, y)
   bitmap = RPG::Cache.battler(actor.character_name + "-face", actor.character_hue) rescue repor
   cw = bitmap.width / 2
  ch = bitmap.height
   self.contents.blt(x - cw, y - ch, bitmap, bitmap.rect, 208)
 end
 
  def draw_actor_state3(actor, x, y, width = 120)
    text = make_battler_state_text(actor, width, true)
    self.contents.font.color = actor.hp == 0 ? DRAWNED_COLOR6 : DRAWNED_COLOR7
    self.contents.draw_text(x, y, width, 32, text)
  end

 
  #--------------------------------------------------------------------------
  # - Desenhar Parâmetro
  #
  #     actor : Herói
  #     x     : Desenhar a partir da coordenada x
  #     y     : Desenhar a partir da coordenada y
  #     width : Desenhar comprimento
  #     type  : tipo de parâmetro (0-6)
  #--------------------------------------------------------------------------
  DRAWNED_COLOR = Color.new(255, 64, 255)
  DRAWNED_COLOR2 = Color.new(0, 150, 255)
  DRAWNED_COLOR3 = Color.new(0, 224, 255, 255)
  DRAWNED_COLOR4 = Color.new(120, 0, 0, 255) #(192, 0, 255, 255)
  DRAWNED_COLOR5 = Color.new(132, 172, 205, 255)#(162, 204, 235, 255)
  DRAWNED_COLOR6 = Color.new(180, 0, 0, 255)#(255, 64, 0, 255)
  DRAWNED_COLOR7 = Color.new(0, 0, 200, 255)
  DRAWNED_COLOR8 = Color.new(0, 0, 0, 255)
  #(255, 64, 0)
  #(192, 224, 255, 255)
  def draw_actor_parameter3(actor, x, y, type)
    case type
    when 0
      self.contents.font.color = DRAWNED_COLOR6
      parameter_name = $data_system.words.atk
      parameter_value = actor.atk
    when 1
      self.contents.font.color = DRAWNED_COLOR2
      parameter_name = $data_system.words.pdef
      parameter_value = actor.pdef
    when 2
      self.contents.font.color =  DRAWNED_COLOR
      parameter_name = $data_system.words.mdef
      parameter_value = actor.mdef
    when 3
      self.contents.font.color = knockout_color
      parameter_name = $data_system.words.str
      parameter_value = actor.str
    when 4
      self.contents.font.color = DRAWNED_COLOR5
      parameter_name = $data_system.words.dex
      parameter_value = actor.dex
    when 5
      self.contents.font.color = DRAWNED_COLOR3
      parameter_name = $data_system.words.agi
      parameter_value = actor.agi
    when 6
      self.contents.font.color = DRAWNED_COLOR4
      parameter_name = $data_system.words.int
      parameter_value = actor.int
    end
    #self.contents.font.color = system_color
    #self.contents.draw_text(x, y, 120, 32, parameter_name)
    #self.contents.font.color = normal_color
    self.contents.draw_text(x, y, 36 + 100, 32, parameter_value.to_s, 2)#(x + 120, y, 36, 32, parameter_value.to_s, 2)
  end
    def draw_actor_name3(actor, x, y)
    self.contents.draw_text(x, y, 120, 32, actor.name)
  end  
 def draw_actor_class3(actor, x, y)
    self.contents.draw_text(x, y, 236, 32, actor.class_name)
  end  
  
  def draw_item_name3(item, x, y)
    if item == nil
      return
    end
    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)
  end
   # def draw_actor_exp(actor, x, y, width = 144)
   # self.contents.font.color = system_color
   # self.contents.draw_text(x, y, 48, 32, "Exp")
   # self.contents.font.color = normal_color
  #  self.contents.draw_text(x + width - 48, y, 48, 32, actor.exp_s, 2)
  #end
      def draw_actor_exp(actor, x, y, width = 144)
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 48, 32, "Exp")
    self.contents.font.color = normal_color
    self.contents.draw_text(x + width - 48, y, 48, 32, actor.exp_s, 2)
  end
  alias cbs_draw_actor_exp draw_actor_exp
  def draw_actor_exp3(actor, x, y, width = 171, height = 15)
    bg = Color.new(  0,   0,   0, 160)
    c1 = Color.new(255,   0,   0, 0)
    c2 = Color.new(255, 255,   0, 160)
    self.contents.fill_rect(x, y, width, height, bg)
    width2 = width * actor.now_exp / actor.next_exp
    gradient(x + 1, y + 1, width2 - 2, height - 2, c1, c2)
    cbs_draw_actor_exp(actor, x, y - 10, width)
  end
  alias cbs_draw_actor_hp draw_actor_hp
  def draw_actor_hp3(actor, x, y, width = 146, height = 15)
    bg = Color.new(  0,   0,   0, 160)
    c1 = Color.new(255,   0,   0, 0)
    c2 = Color.new(255, 255,   0, 160)
    self.contents.fill_rect(x, y, width, height, bg)
    width2 = width * actor.hp / actor.maxhp
    gradient(x + 1, y + 1, width2 - 2, height - 2, c1, c2)
    cbs_draw_actor_hp(actor, x, y - 10, width)
  end
 
  #=============================================

   alias cbs_draw_actor_hp2 draw_actor_hp
  #=============================================
  def draw_actor_hp4(actor, x, y, width = 123, height = 15)
    bg = Color.new(  0,   0,   0, 160)
    c1 = Color.new(255,   0,   0, 0)
    c2 = Color.new(255, 255,   0, 160)

    self.contents.fill_rect(x, y, width, height, bg)
    width2 = width * actor.hp / actor.maxhp
    gradient(x + 1, y + 1, width2 - 2, height - 2, c1, c2)
    #cbs_draw_actor_hp2(actor, x, y - 10, width)#cbs_draw_actor_hp2(actor, x, y - 10, width)
  end
  
    alias cbs_draw_actor_hp3 draw_actor_hp
  def draw_actor_hp5(actor, x, y, width = 15, height = 146)
    bg = Color.new(  0,   0,   0, 160)
    c1 = Color.new(255,   0,   0, 0)
    c2 = Color.new(255, 255,   0, 160)
    self.contents.fill_rect(x, y, width, height, bg)
    height2 = height * actor.hp / actor.maxhp
    gradient(x + 1, y + 1, width - 2, height2 - 2, c1, c2)
    #cbs_draw_actor_hp3(actor, x, y - 10, width)
  end
  
  alias cbs_draw_actor_sp draw_actor_sp
  def draw_actor_sp3(actor, x, y, width = 146, height = 15)
    bg = Color.new(  0,   0,   0, 160)
    c1 = Color.new(  0,   0, 255, 0)
    c2 = Color.new(  0, 255, 255, 160)
    self.contents.fill_rect(x, y, width, height, bg)
    if actor.maxsp != 0
      width2 = width * actor.sp / actor.maxsp
    else
      width2 = width * actor.sp / 1
    end
    gradient(x + 1, y + 1, width2 - 2, height - 2, c1, c2)
    cbs_draw_actor_sp(actor, x, y - 10, width)
  end
   alias cbs_draw_actor_sp2 draw_actor_sp
  def draw_actor_sp4(actor, x, y, width = 146, height = 15)
    bg = Color.new(  0,   0,   0, 160)
    c1 = Color.new(  0,   0, 255, 0)
    c2 = Color.new(  0, 255, 255, 160)
    self.contents.fill_rect(x, y, width, height, bg)
    if actor.maxsp != 0
      width2 = width * actor.sp / actor.maxsp
    else
      width2 = width * actor.sp / 1
    end
    gradient(x + 1, y + 1, width2 - 2, height - 2, c1, c2)
    #cbs_draw_actor_sp(actor, x, y - 10, width)
  end
  def gradient(x, y, width, height, c1, c2)
    for i in 1..width
      x2 = x + i - 1
      r = c1.red * (width - i) / width + c2.red * i / width
      g = c1.green * (width - i) / width + c2.green * i / width
      b = c1.blue * (width - i) / width + c2.blue * i / width
      a = c1.alpha * (width - i) / width + c2.alpha * i / width
      self.contents.fill_rect(x2, y, 1, height, Color.new(r, g, b, a))
    end
  end
end
  
  
  #-----------------------------------------------------------------------------
  # @ Draw resistance wheel
  #-----------------------------------------------------------------------------
  ELEMENT_ORDER = [1, 2, 3, 4, 5, 6, 7, 8]
  GRAPH_SCALINE_COLOR        = Color.new(255, 255, 255, 128)
  GRAPH_SCALINE_COLOR_SHADOW = Color.new(  0,   0,   0, 192)
  GRAPH_LINE_COLOR           = Color.new(255, 255,  64, 255)
  GRAPH_LINE_COLOR_MINUS     = Color.new( 64, 255, 255, 255)
  GRAPH_LINE_COLOR_PLUS      = Color.new(255,  64,  64, 255)
  def draw_actor_element_radar_graph(actor, x, y, radius = 43)
    cx = x + radius + 64
    cy = y + radius + 48
    for loop_i in 0..ELEMENT_ORDER.size
      unless loop_i == 0
        @pre_x  = @now_x
        @pre_y  = @now_y
        @pre_ex = @now_ex
        @pre_ey = @now_ey
        @color1 = @color2
      end
      if loop_i == ELEMENT_ORDER.size
        eo = ELEMENT_ORDER[0]
      else
        eo = ELEMENT_ORDER[loop_i]
      end
      er = actor.element_rate(eo)
      estr = $data_system.elements[eo]
      @color2 = er < 0 ? GRAPH_LINE_COLOR_MINUS : er > 100 ?
                GRAPH_LINE_COLOR_PLUS : GRAPH_LINE_COLOR
      er = er.abs
      th = Math::PI * (0.5 - 2.0 * loop_i / ELEMENT_ORDER.size)
      @now_x  = cx + (radius * Math.cos(th)).floor
      @now_y  = cy - (radius * Math.sin(th)).floor
      @now_wx = cx-6+((radius + 24) * Math.cos(th)).floor - 16
      @now_wy = cy - ((radius + 8)  * Math.sin(th)).floor - 8
      @now_vx = cx + ((radius + 64) * Math.cos(th)).floor - 16
      @now_vy = cy - ((radius + 24) * Math.sin(th)).floor - 8
      @now_ex = cx + (er*radius/100 * Math.cos(th)).floor
      @now_ey = cy - (er*radius/100 * Math.sin(th)).floor
      if loop_i == 0
        @pre_x  = @now_x
        @pre_y  = @now_y
        @pre_ex = @now_ex
        @pre_ey = @now_ey
        @color1 = @color2
      end
      next if loop_i == 0
      #self.contents.draw_line(cx + 1, cy + 1, @now_x + 1, @now_y + 1,
       #                       GRAPH_SCALINE_COLOR_SHADOW)
      self.contents.draw_line(@pre_x + 1, @pre_y + 1, @now_x + 1, @now_y + 1,
                              GRAPH_SCALINE_COLOR_SHADOW)
     self.contents.draw_line(cx,cy, @now_x,@now_y, GRAPH_SCALINE_COLOR)
      self.contents.draw_line(@pre_x,@pre_y, @now_x,@now_y, GRAPH_SCALINE_COLOR)
      self.contents.draw_line(@pre_ex,@pre_ey,@now_ex,@now_ey,@color1,2,@color2)
      self.contents.font.color = GRAPH_SCALINE_COLOR_SHADOW
      self.contents.draw_text(@now_wx, @now_wy, 48, 16, estr, 1)
      self.contents.font.color = GRAPH_LINE_COLOR_PLUS #GRAPH_SCALINE_COLOR_SHADOW
      self.contents.draw_text(@now_vx, @now_vy, 32, 16, er.to_s + "%", 2)
      self.contents.font.color = normal_color
end
end

Crhonos Base P2
Código:
class Window_Base<Window
#===================================================================
#Parte 2
#Saves
#==================================================================
 def picture_file(x,y)
dwf = RPG::Cache.menu("Win_File")
cw = dwf.width
ch = dwf.height
src_rect = Rect.new(0, 0, cw, ch)
self.contents.blt(x , y - ch, dwf, src_rect)    
end
def repor
bitmap = RPG::Cache.picture("")
end
def draw_herofacesH(actor, x, y)
   bitmap = RPG::Cache.battler(actor.character_name + "-face", actor.character_hue) rescue repor
   cw = bitmap.width / 2
  ch = bitmap.height
   self.contents.stretch_blt(Rect.new(x - cw, y - ch, 92, 93), bitmap, Rect.new(0, 0, 138, 147), 208)
 end
 def draw_herofacesI(actor, x, y)
   bitmap = RPG::Cache.battler(actor.character_name + "-face", actor.character_hue) rescue repor
   cw = bitmap.width / 2
  ch = bitmap.height
   self.contents.stretch_blt(Rect.new(x - cw, y - ch, 56, 49), bitmap, Rect.new(0, 0, 138, 147), 208)
 end
#def draw_herofacesH(actor,x,y)
 # bitmap = RPG::Cache.battler(actor.character_name + "-face2", actor.character_hue) rescue repor
#cw = bitmap.width
#ch = bitmap.height
#src_rect = Rect.new(0, 0, cw, ch)
#self.contents.blt(x , y - ch, bitmap, src_rect)    
#end

#def no_name(actor, x, y)
#self.contents.font.color = Color.new(0,0,0,255)
#self.contents.draw_text(x + 1, y + 1, 100, 32, "No char",1)
#self.contents.font.color = normal_color
#self.contents.draw_text(x, y, 100, 32, "No char",1)
#end

def por_name(actor, x, y)
self.contents.font.color = Color.new(0,0,0,255)
self.contents.draw_text(x + 1, y + 1, 100, 32, actor.name,1)
self.contents.font.color = normal_color
self.contents.draw_text(x, y, 100, 32, actor.name,1)
end


#=============================
#P3 Itens
#==============================
#--------------------------------------------------------------------------
# * Draw Item
#  index : item number
#--------------------------------------------------------------------------
end

Game_Party
Código:
#==============================================================================
# Game_Party
#------------------------------------------------------------------------------
# Esta classe engloba o Grupo de Heróis. Isto inclui informações sobre a
# quantidade de dinheiro e Itens. Se refere a $game_party para as instâncias
# nesta classe.
#==============================================================================

class Game_Party

  #--------------------------------------------------------------------------
  # - Ganhou ou Perder Itens
  #
  #     item_id : iD do Item
  #     n       : quantidade
  #--------------------------------------------------------------------------
  
  def gain_item(item_id, n)
    # Atualizar a quantidade nesta divisão
    if n > 0
      itm = []
      for i,j in @items
        if i > 0
          itm.push([i,j])
        end
      end
      mx = 0
      for i in itm
        if i[1] == item_id and i[0] > 0
          mx = 0
          break
        else
          mx += 1
        end
      end
      if mx+1 > 16
        return
      end
    end
    if item_id > 0
      @items[item_id] = [[item_number(item_id) + n, 0].max, 99].min
    end
  end
  
  #--------------------------------------------------------------------------
  # - Ganhar ou Perder Armas
  #
  #     weapon_id : ID da Arma
  #     n         : quantidade
  #--------------------------------------------------------------------------
  
  def gain_weapon(weapon_id, n)
    # Atualizar a quantidade nesta divisão
    if n > 0
      itm = []
      for i,j in @weapons
        if i > 0
          itm.push([i,j])
        end
      end
      mx = 0
      for i in itm
        if i[1] == weapon_id and i[0] > 0
          mx = 0
          break
        else
          mx += 1
        end
      end
      if mx+1 > 16
        return
      end
    end
    if weapon_id > 0
      @weapons[weapon_id] = [[weapon_number(weapon_id) + n, 0].max, 99].min
    end
  end
  
  #--------------------------------------------------------------------------
  # - Ganhar ou Perder Armaduras
  #
  #     armor_id : ID da Armadura
  #     n        : quantidade
  #--------------------------------------------------------------------------
  
  def gain_armor(armor_id, n)
    # Atualizar a quantidade nesta divisão
    if n > 0
      itm = []
      for i,j in @armors
        if i > 0
          itm.push([i,j])
        end
      end
      mx = 0
      for i in itm
        if i[1] == armor_id and i[0] > 0
          mx = 0
          break
        else
          mx += 1
        end
      end
      if mx+1 > 16
        return
      end
    end
    if armor_id > 0
      @armors[armor_id] = [[armor_number(armor_id) + n, 0].max, 99].min
    end
  end
end

Crhonos Scene Item
Código:
#==============================================================================
# Scene_Item
#------------------------------------------------------------------------------
# Esta classe processa a tela de Itens
#==============================================================================

class Scene_Item
 
 #--------------------------------------------------------------------------
 # - Inicialização dos Objetos
 #--------------------------------------------------------------------------
 
 def initialize
   @type_item = 0
   @item_block = $game_temp.in_battle
 end
 
 #--------------------------------------------------------------------------
 # - Processamento Principal
 #--------------------------------------------------------------------------
 
 def main
   # Aqui são criadas as janelas de Ajuda e de Itens
   @help_window = Window_Help3.new
   @item_window = Window_Item3.new
   @item_window_aba = Window_Aba.new
   #Imgs
   @fundo = Sprite.new
   @fundo.bitmap = RPG::Cache.menu("Map Itens")
   @instruçao = Sprite.new
   @instruçao.bitmap = RPG::Cache.menu("L + R")
   # Associar a janela de Ajuda
   @item_window.help_window = @help_window
   # Criar janela alvo (definir como invisível / inativa)
   @target_window = Window_Target3.new
   @target_window.visible = true
   @target_window.active = false
   # Executar transição
   Graphics.transition
   # Loop principal
   loop do
     # Atualizar a tela de jogo
     Graphics.update
     # Atualizar a entrada de informações
     Input.update
     # Atualização do frame
     update
     # Abortar o loop se a tela foi alterada
     if $scene != self
       break
     end
   end
   # Prepara para transição
   Graphics.freeze
   # Exibição das janelas
   @help_window.dispose
   @item_window.dispose
   @target_window.dispose
   @item_window_aba.dispose
   @fundo.dispose
   @instruçao.dispose
 end
 
 #--------------------------------------------------------------------------
 # - Atualização do Frame
 #--------------------------------------------------------------------------
 
 def update
   # Atualizar janelas
   @help_window.update
   @item_window.update
   @target_window.update
   # Se a janela de Itens estiver ativa: chamar update_item
   if @item_window.active
     update_item
     update_item_type
     return
   end
   # Se a janela alvo estiver ativa: chamar update_target
   if @target_window.active
     update_target
     return
   end
 end
 
 #--------------------------------------------------------------------------
 # - Atualização do Frame (Quando a janela de Itens estiver Ativa)
 #--------------------------------------------------------------------------
 
 def update_item
   # Se o botão B for pressionado
   if Input.trigger?(Input::B)
     # Reproduzir SE de cancelamento
     $game_system.se_play($data_system.cancel_se)
     # Alternar para a tela de Menu
     $scene = Scene_Menu.new(0)
     return
   end
   # Se o botão C for pressionado
   if Input.trigger?(Input::C)
     # Selecionar os dados escolhidos na janela de Itens
     @item = @item_window.item
     # Se não for um Item usável
     unless @item.is_a?(RPG::Item)
       # Reproduzir SE de erro
       $game_system.se_play($data_system.buzzer_se)
       return
     end
     # Se não puder ser usado
     unless $game_party.item_can_use?(@item.id)
       # Reproduzir SE de erro
       $game_system.se_play($data_system.buzzer_se)
       return
     end
     # Reproduzir SE de OK
     $game_system.se_play($data_system.decision_se)
     # Se o alcance do Item for um aliado
     if @item.scope >= 3
       # Ativar a janela alvo
       @item_window.active = false
       #@target_window.x = (@item_window.index + 1) % 2 * 304
       #@target_window.visible = true
       @target_window.active = true
       # Definir a posição do cursor no alvo (aliado / todo grupo)
       if @item.scope == 4 || @item.scope == 6
         @target_window.index = -1
       else
         @target_window.index = 0
       end
     # Se o alcance for outro senão um aliado
     else
       # Se o ID do evento comum for inválido
       if @item.common_event_id > 0
         # Chamar evento comum da reserva
         $game_temp.common_event_id = @item.common_event_id
         # Reproduzir SE do Item
         $game_system.se_play(@item.menu_se)
         # Se for consumível
         if @item.consumable
           # Diminui 1 Item da quantidade total
           $game_party.lose_item(@item.id, 1)
           # Desenhar o Item
           @item_window.draw_item(@item_window.index)
         end
         # Alternar para a tela do Mapa
         $scene = Scene_Map.new
         return
       end
     end
     return
   end
 end
   
 #--------------------------------------------------------------------------
 # - Atualização do Frame(Tipo do item)
 #--------------------------------------------------------------------------
 
 def update_item_type
   if @item_block
     $game_system.se_play($data_system.buzzer_se)
     return
   end
   last_index = @type_item
   next_item = false
   return_item = false
   if Input.trigger?(Input::L)
     @item_window.index = 0
     @type_item -= 1
     return_item = true
   elsif Input.trigger?(Input::R)
     @item_window.index = 0
     @type_item += 1
     next_item = true
   end
   @type_item = 3 if @type_item < 0
   @type_item = 0 if @type_item > 3
   if next_item and zero_item(@type_item)
     loop do
       if @type_item == 3
         @type_item = 0
         break
       end
       @type_item += 1
       next if zero_item(@type_item)
     end
   elsif return_item and zero_item(@type_item)
     loop do
       if @type_item == 0
         break
       end
       @type_item -= 1
       next if zero_item(@type_item)
     end
   end
   if last_index == @type_item and (return_item or next_item)
     $game_system.se_play($data_system.buzzer_se)
   end
   if @item_window.type_item != @type_item
     Graphics.freeze
     @item_window.refresh_item_type(@type_item)
     @item_window_aba.refresh(@type_item)
     Graphics.transition
   end
 end
 
 #--------------------------------------------------------------------------
 # - Se a quantidade de um tipo de item é == 0
 #--------------------------------------------------------------------------
 
 def zero_item(type)
   item_number = 0
   case type
   when 0
     for i in 1...$data_items.size
       if $game_party.item_number(i) > 0
         item_number += 1
       end
     end
   when 1
     for i in 1...$data_weapons.size
       if $game_party.weapon_number(i) > 0
         item_number += 1
       end
     end
   when 2 .. 3
     for i in 1...$data_armors.size
       if $game_party.armor_number(i) > 0
         item_number += 1
       end
     end
   end
   item_number == 0
 end
 
 #--------------------------------------------------------------------------
 # - Atualização do Frame (Quando a janela alvo estiver Ativa)
 #--------------------------------------------------------------------------
 
 def update_target
   # Se o botão B for pressionado
   if Input.trigger?(Input::B)
     # Reproduzir SE de cancelamento
     $game_system.se_play($data_system.cancel_se)
     # Se for impossível utilizar porque o Item não existe mais
     unless $game_party.item_can_use?(@item.id)
       # Recriar os conteúdos da janela de ìtens
       @item_window.refresh
     end
     # Apagar a janela alvo
     @item_window.active = true
     #@target_window.visible = false
     @target_window.active = false
     return
   end
   # Se o botão C for pressionado
   if Input.trigger?(Input::C)
     # Se chegar ao número 0 da quantidade de Itens
     if $game_party.item_number(@item.id) == 0
       # Reproduzir SE de erro
       $game_system.se_play($data_system.buzzer_se)
       return
     end
     # Se o alvo for todos o Grupo
     if @target_window.index == -1
       # Os efeitos serão aplicados a todos
       used = false
       for i in $game_party.actors
         used |= i.item_effect(@item)
       end
     end
     # Se for apenas um aliado o alvo
     if @target_window.index >= 0
       # Aplicar os efeitos apenas no Herói alvo
       target = $game_party.actors[@target_window.index]
       used = target.item_effect(@item)
     end
     # Se o Item for usado
     if used
       # Reproduzir SE do Item
       $game_system.se_play(@item.menu_se)
       # Se for consumível
       if @item.consumable
         # Diminui 1 item da quantidade total
         $game_party.lose_item(@item.id, 1)
         # Redesenhar o Item
         @item_window.draw_item(@item_window.index)
       end
       # Recriar os conteúdos da janela alvo
       @target_window.refresh
       # Se todos no Grupo de Heróis estiverm mortos
       if $game_party.all_dead?
         # Alternar para a tela de Game Over
         $scene = Scene_Gameover.new
         return
       end
       # Se o ID do evento comum for válido
       if @item.common_event_id > 0
         # Chamar o evento comum da reserva
         $game_temp.common_event_id = @item.common_event_id
         # Alternar para a tela do Mapa
         $scene = Scene_Map.new
         return
       end
       @item_window.refresh
     end
     # Se o Item não for usado
     unless used
       # Reproduzir SE de erro
       $game_system.se_play($data_system.buzzer_se)
     end
     return
   end
 end
end



#==============================================================================
# Window_Aba
#------------------------------------------------------------------------------
# Esta janela exibe as abas dos tipos de items.
#==============================================================================

class Window_Aba < Window_Selectable
   
 #--------------------------------------------------------------------------
 # - Inicialização dos Objetos
 #--------------------------------------------------------------------------
 
 def initialize
   super(0, 0, 640, 120)
   self.contents = Bitmap.new(640-32, 120-32)
   self.contents.font.name = $fontface
   self.contents.font.size = $fontsize
   self.opacity = 0
   refresh(0)
 end
   
 #--------------------------------------------------------------------------
 # - Atualizar
 #--------------------------------------------------------------------------
 
 def refresh(pos)
   self.contents.clear
   bitmap_in = RPG::Cache.menu("Claro")
   rect = Rect.new(0, 0, bitmap_in.width, bitmap_in.height)
   self.contents.blt((pos*bitmap_in.width)-2, -1, bitmap_in, rect)
   self.contents.font.color = color(0, pos)
   self.contents.draw_text(50, 7, 640, 32, type(0), 0)
   self.contents.font.color = color(1, pos)
   self.contents.draw_text(180, 7, 640, 32, type(1), 0)
   self.contents.font.color = color(2, pos)
   self.contents.draw_text(318, 7, 640, 32, type(2), 0)
   self.contents.font.color = color(3, pos)
   self.contents.draw_text(495, 7, 640, 32, type(3), 0)
 end
   
 #--------------------------------------------------------------------------
 # - Tipo do item
 #--------------------------------------------------------------------------
 
 def type(id)
   case id
   when 0
     "Itens"
   when 1
     "Weapons"
   when 2
     "Shield/Armor"
   when 3
     "Misc."
   end
 end
   
 #--------------------------------------------------------------------------
 # - Cor
 #--------------------------------------------------------------------------
 
 def color(id, id2)
   if id == id2
     Color.new(255, 255, 255)
   else
     disabled_color
   end
 end
end




#==============================================================================
# Window_Item
#------------------------------------------------------------------------------
# Esta janela exibe os Itens possuídos na tela de Itens
#==============================================================================

class Window_Item3 < Window_Selectable

 #--------------------------------------------------------------------------
 # - Inicialização dos Objetos
 #--------------------------------------------------------------------------
 
 def initialize
   super(320, 65, 262, 228)
   @item_type = 0
   @column_max = 4
   #@item_max = 16
   refresh
   self.index = 0
   self.windowskin = RPG::Cache.windowskin("cursor")
   # Caso se está em uma batalha a janela será movida para o centro da tela
   # e esta é transformada em semi-transparente
   self.opacity = 140
   if $game_temp.in_battle
     self.y = 64
     self.height = 256
     self.back_opacity = 160
   end
 end
 
 #--------------------------------------------------------------------------
 # - Selecionar Item
 #--------------------------------------------------------------------------
 
 def item
   return @data[self.index]
 end
 
 #--------------------------------------------------------------------------
 # - Atualização
 #--------------------------------------------------------------------------
 
 def refresh
   if self.contents != nil
     self.contents.dispose
     self.contents = nil
   end
   @data = []
   # Adicionar Item
   if @item_type == 0
     for i in 1...$data_items.size
       if $game_party.item_number(i) > 0
         @data.push($data_items[i])
       end
     end
   end
   # Também é adicionados os equipamentos e os Itens chave caso se esteja fora
   # de uma batalha
   unless $game_temp.in_battle
     if @item_type == 1
       for i in 1...$data_weapons.size
         if $game_party.weapon_number(i) > 0
           @data.push($data_weapons[i])
         end
       end
     end
     for i in 1...$data_armors.size
       if $game_party.armor_number(i) > 0
         add = false
         case $data_armors[i].kind
         when 0
           if @item_type == 2
             add = true
           end
         when 1
           if @item_type == 3
             add = true
           end
         when 2
           if @item_type == 2
             add = true
           end
         when 3
           if @item_type == 3
             add = true
           end
         end
         if add
           @data.push($data_armors[i])
         end
       end
     end
   end
   # Caso haja algum Item aqui a janela é desenhada, junto com todos os Itens
   @item_max = @data.size
   if @item_max > 0
     self.contents = Bitmap.new(width - 32, row_max * 50)
     for i in 0...@item_max
       draw_item(i)
     end
   end
 end
 
 def type_item
   @item_type
 end
 
 def refresh_item_type(type)
   @item_type = type
   refresh
 end
 
 #--------------------------------------------------------------------------
 # - Desenhar Item
 #
 #     index : índice de Itens
 #--------------------------------------------------------------------------
 def draw_item(index)
 item = @data[index]
 case item
 when RPG::Item
  number = $game_party.item_number(item.id)
 when RPG::Weapon
  number = $game_party.weapon_number(item.id)
 when RPG::Armor
  number = $game_party.armor_number(item.id)
 end
 if item.is_a?(RPG::Item) and
  $game_party.item_can_use?(item.id)
  self.contents.font.color = normal_color
 else
  self.contents.font.color = disabled_color
 end
 x = index % 4 * 60 # 4 + index % 10 * (32 + 32)
 y = index / 4 * 50 #index / 10 * 32
 rect = Rect.new(x, y + 32,self.width / @column_max - 32,64 )#self.width / @column_max - 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
 item_x = x + 30 - bitmap.width / 2
 item_y = y + 25 - bitmap.height / 2
 self.contents.blt(item_x, item_y, bitmap, Rect.new(0, 0, 24, 24), opacity)
 self.contents.draw_text(item_x, item_y + 9, 24, 32, number.to_s, 2)

 end
 #--------------------------------------------------------------------------
 # - Atualização do Texto de Ajuda
 #--------------------------------------------------------------------------
def update_cursor_rect
   if @index < 0
     self.cursor_rect.empty
     return
   end
   row = @index / @column_max
   if row < self.top_row
     self.top_row = row
   end
   if row > self.top_row + (self.page_row_max - 1)
     self.top_row = row - (self.page_row_max - 1)
   end
   cursor_width =  58
   
   x = @index % @column_max * (30 + 30)
   y = @index / @column_max * (26 + 26)
   self.cursor_rect.set(x, y, cursor_width, 48)#self.cursor_rect.set(x, y, cursor_width, 32)
 end
 
 def update_help
   if @help_window != nil
     @help_window.set_item(self.item)
   end
 end
 
end



#==============================================================================
# Window_Target
#------------------------------------------------------------------------------
# Exibição de uma janela ao utilizar Itens ou Habilidades
#==============================================================================

class Window_Target3 < Window_Selectable
 
 #--------------------------------------------------------------------------
 # - Inicialização dos Objetos
 #--------------------------------------------------------------------------
 
 def initialize
   super(20, 50, 300, 320) #336, 480
   self.contents = Bitmap.new(width - 32, height - 32)
 
   self.contents.font.name = "Arial Black" #Fontes Rec: Arial Black,Bookman Old Style, $fontface
   #self.contents.font.color = DRAWNED_COLOR8
   self.contents.font.size = 18
   self.windowskin = RPG::Cache.windowskin("cursor")
   self.z += 10
   #self.opacity = 140
   @item_max = $game_party.actors.size
   refresh
 end
 
 #--------------------------------------------------------------------------
 # - Atualizar
 #--------------------------------------------------------------------------
 
 def refresh
   self.contents.clear
   for i in 0...$game_party.actors.size
     x = 4 #x = 4
     y = i * 70 #y = i * 116
     actor = $game_party.actors[i]
     draw_actor_name(actor, x + 80, y)
     draw_actor_class(actor, x + 80, y + 25)
     draw_actor_level(actor, x + 164, y)
     #draw_actor_state(actor, x + 8, y + 40)
     draw_herofacesI(actor,86,y + 163)
     draw_actor_hp4(actor, x + 164, y + 35,64, 12)
     draw_actor_sp4(actor, x + 164, y + 55,64, 12)
     draw_actor_state(actor, x + 80, y + 45)
     #self.contents.font.size = 22
     self.contents.draw_text( x + 158, y + 25, 32, 32, "HP", 1)
     self.contents.draw_text( x + 158, y + 45, 32, 32, "MP", 1)
   end
 end
 
 #--------------------------------------------------------------------------
 # - Renovação do Retângulo de Seleção
 #--------------------------------------------------------------------------
 
 def update_cursor_rect
   # Se define a posição atual -1
   if @index < 0
     self.cursor_rect.set(0, 0, self.width - 32,79)#self.cursor_rect.set(0, 0, self.width - 32, @item_max * 116 - 20)
   else
     self.cursor_rect.set(0, @index * 70, self.width - 32,79)#self.cursor_rect.set(0, @index * 116, self.width - 32, 96)
   end
 end
end



#==============================================================================
# Window_Help
#------------------------------------------------------------------------------
# Esta classe exibe uma janela de explicação para Habilidades e Itens.
#==============================================================================

class Window_Help3 < Window_Base
 
 #--------------------------------------------------------------------------
 # - Inicialização dos Objetos
 #--------------------------------------------------------------------------
 
 def initialize
   super(118, 280, 500, 96 + (350 - 285))#480
   self.contents = Bitmap.new(width - 32, height - 32)
   self.windowskin = RPG::Cache.windowskin("cursor")
 end
 
 #--------------------------------------------------------------------------
 # - Definição do Texto
 #
 #  text  : texto exibido na janela
 #  align : alinhamento (0 = esquerda, 1 = centralizado, 2 = direita)
 #--------------------------------------------------------------------------
 
 def set_text(text, align = 0)
   # Caso algum alinhamento do texto ficar diferente de alguma outra parte...
   if text != @text or align != @align
     # O texto é redesenhado.
     self.contents.clear
     self.contents.font.color = normal_color
     self.contents.draw_text(4, 0, self.width - 40, 32, text, align)
     @text = text
     @align = align
     @actor = nil
   end
   self.visible = true
 end
 
 def set_item(item, align=0)
   if @item != item
     @item = item
     self.contents.clear
     self.contents.font.color = normal_color
     unless @item.nil?
       bitmap = RPG::Cache.icon(@item.icon_name)
       x = (320 - self.x) - 16
       y = (290 - self.y) - 16
       self.contents.blt(x + 30 - bitmap.width / 2, y + 25 - bitmap.height / 2, bitmap, Rect.new(0, 0, 24, 24))
       self.contents.draw_text(x + 100, y, self.width - 68, 32, @item.name, align)
       self.contents.draw_text(4, 366 - self.y - 16, self.width - 40, 32, @item.description, align)
     end
   end
   self.visible = true
 end
   
 
 #--------------------------------------------------------------------------
 # - Definição do Herói
 #
 #     actor : exibição do Status do Persongem
 #--------------------------------------------------------------------------
 
 def set_actor(actor)
   if actor != @actor
     self.contents.clear
     draw_actor_name(actor, 4, 0)
     draw_actor_state(actor, 140, 0)
     draw_actor_hp(actor, 284, 0)
     draw_actor_sp(actor, 460, 0)
     @actor = actor
     @text = nil
     self.visible = true
   end
 end
 
 #--------------------------------------------------------------------------
 # - Definição do Inimigo
 #
 #     enemy : Exibição do nome e do Status do Inimigo
 #--------------------------------------------------------------------------
 
 def set_enemy(enemy)
   text = enemy.name
   state_text = make_battler_state_text(enemy, 112, false)
   if state_text != ""
     text += "  " + state_text
   end
   set_text(text, 1)
 end
end

IMÁGENES NECESARIAS + DEMOSTRACIÓN
http://share.cherrytree.at/showfile-31078/crhonos_scene_item_dq8.rar
avatar
AsFzKakarotto
Soñador
Soñador

0/3

Créditos 314

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.