RGSS3 DIY - Menu Circular

#==============================================================================
# Menu Circular | v1.0.0 | por Masked
#
# para RPG Maker VX Ace
#------------------------------------------------------------------------------
#  Modifica o menu para um círculo de ícones em volta do jogador.
#==============================================================================
#==============================================================================
# ** RingMenu
#------------------------------------------------------------------------------
#  Este modulo define as configurações do menu circular.
#==============================================================================
module RingMenu
  # Ícones
  GOLD_ICON     = 361
  ICONS         = {
    item:       192,
    skill:      8,
    equip:      164,
    status:     4,
    formation:  121,
    save:       117,
    game_end:   0
  }

  # Tamanho da fonte
  FONT_SIZE     = 24

  # Duração da rotação
  SPIN_DURATION = 16

  # Raio do anel
  RADIUS        = 128
end
#==============================================================================
# ** Scene_Menu
#------------------------------------------------------------------------------
#  Esta classe executa o processamento da tela de menu.
#==============================================================================
class Scene_Menu < Scene_MenuBase
  #--------------------------------------------------------------------------
  # * Inicialização do processo
  #--------------------------------------------------------------------------
  def start
    super
    create_player
    create_gold_window
    create_command_ring
    create_character_ring
  end
  #--------------------------------------------------------------------------
  # * Cria o sprite do jogador
  #--------------------------------------------------------------------------
  def create_player
    @player = Sprite_Character.new(@viewport, $game_player)
  end
  #--------------------------------------------------------------------------
  # * Cria o anel de comandos
  #--------------------------------------------------------------------------
  def create_command_ring
    @command_window = CommandRing.new
    @command_window.set_handler(:item,      method(:command_item))
    @command_window.set_handler(:skill,     method(:command_personal))
    @command_window.set_handler(:equip,     method(:command_personal))
    @command_window.set_handler(:status,    method(:command_personal))
    @command_window.set_handler(:formation, method(:command_formation))
    @command_window.set_handler(:save,      method(:command_save))
    @command_window.set_handler(:game_end,  method(:command_game_end))
    @command_window.set_handler(:cancel,    method(:return_scene))
  end
  #--------------------------------------------------------------------------
  # * Cria o anel de personagens
  #--------------------------------------------------------------------------
  def create_character_ring
    @status_window = CharacterRing.new
    @status_window.deactivate
    @status_window.update
  end
  #--------------------------------------------------------------------------
  # * Atualização da tela
  #--------------------------------------------------------------------------
  def update
    super
    @player.update
  end
  #--------------------------------------------------------------------------
  # * Finalização do processo
  #--------------------------------------------------------------------------
  def terminate
    super
    @player.dispose
  end
end
#==============================================================================
# ** Window_Gold
#------------------------------------------------------------------------------
#  Esta janela exibe a quantia de dinheiro.
#==============================================================================
class Window_Gold < Window_Base
  #--------------------------------------------------------------------------
  # * Aliases
  #--------------------------------------------------------------------------
  alias ring_menu_initialize  initialize
  alias ring_menu_refresh     refresh
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize
    ring_menu_initialize
    self.opacity = 0
  end
  #--------------------------------------------------------------------------
  # * Renovação
  #--------------------------------------------------------------------------
  def refresh
    ring_menu_refresh
    draw_icon(RingMenu::GOLD_ICON, 0, 0)
  end
end
#==============================================================================
# ** CommandRing
#------------------------------------------------------------------------------
#  Esta classe representa um anel de comandos do menu circular.
#==============================================================================
class CommandRing < Window_MenuCommand
  #--------------------------------------------------------------------------
  # * Atributos
  #--------------------------------------------------------------------------
  attr_accessor   :active
  attr_accessor   :index
  attr_reader     :spin
  attr_reader     :list
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize
    clear_command_list
    make_command_list
    @active = true
    @handler = {}
    @index = 0
    @spin = 0
    create_spriteset
  end
  #--------------------------------------------------------------------------
  # * Criação do spriteset
  #--------------------------------------------------------------------------
  def create_spriteset
    @spriteset = Spriteset_CommandRing.new(self)
  end
  #--------------------------------------------------------------------------
  # * Verifica se o menu está aberto
  #--------------------------------------------------------------------------
  def open?
    true
  end
  #--------------------------------------------------------------------------
  # * Atualização do objeto
  #--------------------------------------------------------------------------
  def update
    process_cursor_move
    process_handling
    update_spin
    update_spriteset
  end
  #--------------------------------------------------------------------------
  # * Atualização da rotação
  #--------------------------------------------------------------------------
  def update_spin
    @spin -= @spin <=> 0
  end
  #--------------------------------------------------------------------------
  # * Atualização do spriteset
  #--------------------------------------------------------------------------
  def update_spriteset
    @spriteset.update
  end
  #--------------------------------------------------------------------------
  # * Execução da rotação do anel
  #--------------------------------------------------------------------------
  def process_cursor_move
    return unless cursor_movable?
    dir = Input.dir4
    return if dir.zero?
    Sound.play_cursor
    return prev_item if dir > 5
    return next_item
  end
  #--------------------------------------------------------------------------
  # * Verifica se pode mover o cursor
  #--------------------------------------------------------------------------
  def cursor_movable?
    active and @spin == 0
  end
  #--------------------------------------------------------------------------
  # * Avança um item
  #--------------------------------------------------------------------------
  def next_item
    @index += 1
    @index %= @list.size
    @spin = -RingMenu::SPIN_DURATION
  end
  #--------------------------------------------------------------------------
  # * Volta um item
  #--------------------------------------------------------------------------
  def prev_item
    @index -= 1
    @index %= @list.size
    @spin = RingMenu::SPIN_DURATION
  end
  #--------------------------------------------------------------------------
  # * Disposição do objeto
  #--------------------------------------------------------------------------
  def dispose
    @spriteset.dispose
  end
end
#==============================================================================
# ** CharacterRing
#------------------------------------------------------------------------------
#  Esta classe representa um anel de personagens do menu circular.
#==============================================================================
class CharacterRing < CommandRing
  #--------------------------------------------------------------------------
  # * Variáveis públicas
  #--------------------------------------------------------------------------
  attr_reader   :pending_index            # Manter a posição (para organizar)
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #--------------------------------------------------------------------------
  def initialize
    super
    @pending_index = -1
  end
  #--------------------------------------------------------------------------
  # * Criação do spriteset
  #--------------------------------------------------------------------------
  def create_spriteset
    @spriteset = Spriteset_CharacterRing.new(self)
  end
  #--------------------------------------------------------------------------
  # * Criação da lista de comandos
  #--------------------------------------------------------------------------
  def make_command_list
    for actor in $game_party.members
      add_command(actor.name, actor)
    end
  end
  #--------------------------------------------------------------------------
  # * Redesenho do item
  #     index : índice do item
  #--------------------------------------------------------------------------
  def redraw_item(index)
  end
  #--------------------------------------------------------------------------
  # * Ativação da janela
  #--------------------------------------------------------------------------
  def activate
    super
    clear_command_list
    make_command_list
    @spriteset.redraw
  end
  #--------------------------------------------------------------------------
  # * Processamento de confirmação
  #--------------------------------------------------------------------------
  def process_ok
    super
    $game_party.menu_actor = $game_party.members[index]
  end
  #--------------------------------------------------------------------------
  # * Retorno à seleção anterior
  #--------------------------------------------------------------------------
  def select_last
    select($game_party.menu_actor.index || 0)
  end
  #--------------------------------------------------------------------------
  # * Definição de última posição (para organizar)
  #--------------------------------------------------------------------------
  def pending_index=(index)
    last_pending_index = @pending_index
    @pending_index = index
  end
end
#==============================================================================
# ** Sprite_CommandRingItem
#------------------------------------------------------------------------------
#  Este sprite é usado para exibir itens no anel do menu em círculo.
#==============================================================================
class Sprite_CommandRingItem < Sprite
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #     viewport  : camada
  #     label     : rótulo
  #     symbol    : comando
  #--------------------------------------------------------------------------
  def initialize(viewport, label, symbol)
    super(viewport)
    @label = label
    @symbol = symbol
    create_bitmap
  end
  #--------------------------------------------------------------------------
  # * Redesenha o sprite
  #--------------------------------------------------------------------------
  def redraw
    self.bitmap.dispose if self.bitmap
    create_bitmap
  end
  #--------------------------------------------------------------------------
  # * Criação do bitmap
  #--------------------------------------------------------------------------
  def create_bitmap
    width = [icon_width, label_width].max
    height = icon_height + label_height
    self.bitmap = Bitmap.new(width, height)
    draw_icon
    draw_label
    self.ox = self.bitmap.width / 2
    self.oy = self.bitmap.height / 2
  end
  #--------------------------------------------------------------------------
  # * Largura do ícone
  #--------------------------------------------------------------------------
  def icon_width
    24
  end
  #--------------------------------------------------------------------------
  # * Altura do ícone
  #--------------------------------------------------------------------------
  def icon_height
    24
  end
  #--------------------------------------------------------------------------
  # * Largura do rótulo
  #--------------------------------------------------------------------------
  def label_width
    bitmap = Cache.empty_bitmap
    bitmap.font.size = RingMenu::FONT_SIZE
    bitmap.text_size(@label).width
  end
  #--------------------------------------------------------------------------
  # * Altura do rótulo
  #--------------------------------------------------------------------------
  def label_height
    RingMenu::FONT_SIZE
  end
  #--------------------------------------------------------------------------
  # * Desenha o ícone
  #--------------------------------------------------------------------------
  def draw_icon
    iconset = Cache.system("Iconset")
    icon_index = RingMenu::ICONS[@symbol]
    rect = Rect.new(0, 0, 24, 24)
    rect.x = icon_index % 16 * 24
    rect.y = icon_index / 16 * 24
    self.bitmap.blt((width - rect.width) / 2, 0, iconset, rect)
  end
  #--------------------------------------------------------------------------
  # * Desenha o rótulo
  #--------------------------------------------------------------------------
  def draw_label
    rect = Rect.new(0, icon_height, self.width, label_height)
    self.bitmap.draw_text(rect, @label, 1)
  end
end
#==============================================================================
# ** Sprite_CharacterRingItem
#------------------------------------------------------------------------------
#  Este sprite é usado para exibir personagens no anel do menu em círculo.
#==============================================================================
class Sprite_CharacterRingItem < Sprite_CommandRingItem
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #     viewport  : camada
  #     actor     : personagem (Game_Actor)
  #--------------------------------------------------------------------------
  def initialize(viewport, actor)
    @actor = actor
    @animate = false
    @pattern = 0
    @anime_count = 0
    super(viewport, actor.name, nil)
  end
  #--------------------------------------------------------------------------
  # * Bitmap do charset
  #--------------------------------------------------------------------------
  def charset
    Cache.character(@actor.character_name)
  end
  #--------------------------------------------------------------------------
  # * Largura do ícone
  #--------------------------------------------------------------------------
  def icon_width
    sign = @actor.character_name[/^[\!\$]./]
    if sign && sign.include?('$')
      charset.width / 3
    else
      charset.width / 12
    end
  end
  #--------------------------------------------------------------------------
  # * Altura do ícone
  #--------------------------------------------------------------------------
  def icon_height
    sign = @actor.character_name[/^[\!\$]./]
    if sign && sign.include?('$')
      charset.height / 4
    else
      charset.height / 8
    end
  end
  #--------------------------------------------------------------------------
  # * Retângulo do char
  #--------------------------------------------------------------------------
  def character_rect
    index = @actor.character_index
    pattern = 1
    direction = 2
    cw = icon_width
    ch = icon_height
    sx = (index % 4 * 3 + pattern) * cw
    sy = (index / 4 * 4 + (direction - 2) / 2) * ch
    Rect.new(sx, sy, cw, ch)
  end
  #--------------------------------------------------------------------------
  # * Desenha o ícone
  #--------------------------------------------------------------------------
  def draw_icon
    x = (width - icon_width) / 2
    y = 0
    self.bitmap.clear_rect(x, y, icon_width, icon_height)
    self.bitmap.blt(x, y, charset, character_rect)
  end
end
#==============================================================================
# ** Spriteset_CommandRing
#------------------------------------------------------------------------------
#  Classe　do spriteset dos comandos em anel do menu.
#==============================================================================
class Spriteset_CommandRing
  #--------------------------------------------------------------------------
  # * Inicialização do objeto
  #     parent    : CommandRing
  #     viewport  : camada
  #--------------------------------------------------------------------------
  def initialize(parent, viewport = nil)
    @parent = parent
    @viewport = viewport
    redraw
  end
  #--------------------------------------------------------------------------
  # * Redesenho do spriteset
  #--------------------------------------------------------------------------
  def redraw
    dispose if @items
    clear_items
    create_items
    update
  end
  #--------------------------------------------------------------------------
  # * Limpeza dos itens
  #--------------------------------------------------------------------------
  def clear_items
    @items = []
  end
  #--------------------------------------------------------------------------
  # * Criação dos itens
  #--------------------------------------------------------------------------
  def create_items
    for item in @parent.list
      add_item(item[:name], item[:symbol])
    end
  end
  #--------------------------------------------------------------------------
  # * Adiciona um item ao spriteset
  #     label   : rótulo do comando
  #     symbol  : comando
  #--------------------------------------------------------------------------
  def add_item(label, symbol)
    @items.push(Sprite_CommandRingItem.new(@viewport, label, symbol))
  end
  #--------------------------------------------------------------------------
  # * Atualização do objeto
  #--------------------------------------------------------------------------
  def update
    @items.each(&:update)
    update_items
  end
  #--------------------------------------------------------------------------
  # * Atualização dos itens do anel
  #--------------------------------------------------------------------------
  def update_items
    for item, index in @items.each_with_index
      item.x = adjust_x(index)
      item.y = adjust_y(index)
      item.opacity = selected?(index) ? 255 : 125
      item.visible = @parent.active
    end
  end
  #--------------------------------------------------------------------------
  # * Verifica se um índice está selecionado
  #--------------------------------------------------------------------------
  def selected?(index)
    index == @parent.index
  end
  #--------------------------------------------------------------------------
  # * Calcula o ângulo de um item no anel
  #     index : Índice do item
  #--------------------------------------------------------------------------
  def adjust_angle(index)
    spin = @parent.spin.to_f / RingMenu::SPIN_DURATION
    relative_index = index - @parent.index
    (relative_index - spin) * Math::PI * 2 / @items.size + angle_offset
  end
  #--------------------------------------------------------------------------
  # * Deslocamento angular
  #--------------------------------------------------------------------------
  def angle_offset
    Math::PI / 2
  end
  #--------------------------------------------------------------------------
  # * Calcula a posição X de um item
  #     index : Índice do item
  #--------------------------------------------------------------------------
  def adjust_x(index)
    center_x + Math.cos(adjust_angle(index)) * radius
  end
  #--------------------------------------------------------------------------
  # * Calcula a posição Y de um item
  #     index : Índice do item
  #--------------------------------------------------------------------------
  def adjust_y(index)
    center_y + Math.sin(adjust_angle(index)) * radius
  end
  #--------------------------------------------------------------------------
  # * Posição X do centro do anel
  #--------------------------------------------------------------------------
  def center_x
    $game_player.screen_x
  end
  #--------------------------------------------------------------------------
  # * Posição Y do centro do anel
  #--------------------------------------------------------------------------
  def center_y
    $game_player.screen_y
  end
  #--------------------------------------------------------------------------
  # * Raio do anel
  #--------------------------------------------------------------------------
  def radius
    RingMenu::RADIUS
  end
  #--------------------------------------------------------------------------
  # * Disposição do objeto
  #--------------------------------------------------------------------------
  def dispose
    @items.each(&:dispose)
  end
end
#==============================================================================
# ** Spriteset_CharacterRing
#------------------------------------------------------------------------------
#  Classe　do spriteset da seleção dos personagens em anel do menu.
#==============================================================================
class Spriteset_CharacterRing < Spriteset_CommandRing
  #--------------------------------------------------------------------------
  # * Adiciona um item ao spriteset
  #     name  : nome do personagem
  #     actor : personagem (Game_Actor)
  #--------------------------------------------------------------------------
  def add_item(name, actor)
    @items.push(Sprite_CharacterRingItem.new(@viewport, actor))
  end
  #--------------------------------------------------------------------------
  # * Verifica se um índice está selecionado
  #--------------------------------------------------------------------------
  def selected?(index)
    super or index == @parent.pending_index
  end
end