Últimos temas
» Concurso de relatos - Septiembre/Octubre 2018 [Inscripción]
por Muzgar Ayer a las 11:38 pm

» ¿Cómo puedo poner personajes descargados de internet en mi RPG MAKER MV?
por Muzgar Ayer a las 5:46 pm

» Virtual Kingom (Old Version)
por NinjaLOL Ayer a las 2:55 am

» [VX/ACE] Tileset Moderno del MV
por Muzgar Mar Oct 16, 2018 11:39 pm

» [Ace]Movimiento Libre
por brrt Lun Oct 15, 2018 3:57 pm

» Laminación [VXACE] [PROYECTO EN CURSO]
por Pocari Vie Oct 12, 2018 12:08 pm

» QUITAR VENTANA DEL MENU (VX ACE)
por THESHINYMISTERXD Sáb Oct 06, 2018 7:46 pm

» Condición para saber si el jugador está caminando
por Sonik Sáb Oct 06, 2018 5:03 pm

» ¿Tileset de un futbolín?
por MCarlos15 Jue Oct 04, 2018 9:07 pm

» RPG Maker VX Ace en MAC
por Er1ck_92 Mar Oct 02, 2018 8:42 am

» Distrito 0 [VXACE]
por BREAK93 Mar Oct 02, 2018 6:08 am

» Necesito taileset modernos pero que no tengan estilo anime por favor
por Doble D Mar Oct 02, 2018 12:36 am


[VX]Menu Anillo

Ir abajo

[VX]Menu Anillo

Mensaje por JapoZero el Lun Feb 10, 2014 5:27 pm

Este menu es una buena alternativa si quieres usar otro que no sea el default, pero por mi parte no me gusta. Igual aqui lo tienen:



Se necesitaran estas imagenes en Grafic Pictures para que funcione:
Spoiler:








Pueden editarlas pero No cambiarles el nombre:

Y ahora los scripts, son 2, y son separados, no los junten.

Código:

#==============================================================================
# ** Ring Menu
#-------------------------------------------------------------------------------
# by Syvkal
# Version 1.1
# 06-23-08
#==============================================================================

   #===================================================#
   #  **  C O N F I G U R A T I O N   S Y S T E M  **  #
   #===================================================#
  
  # Amount of frames for Startup Animation
  STARTUP_FRAMES = 20
  # Amount of frames for Movement Animation
  MOVING_FRAMES = 15
  # Radius of the Menu Ring
  RING_R = 75
  # Disabled icon to display when disabled
  ICON_DISABLE= Cache::picture('Icon_Disable')
  
  
   #-------------D-O---N-O-T---T-O-U-C-H---------------#
  
  class Scene_Title < Scene_Base
    alias game_objects_original create_game_objects
    def create_game_objects
      game_objects_original
  
   #-------------D-O---N-O-T---T-O-U-C-H---------------#
  
  # As this script allows you to make a custom Menu I thought to make it easier
  # I would make it possible to add extra Menu Options from here
  
  # All you need to do is specify the Text to display, the icon and the command
  # The command must be in a STRING
  # Simply add to the array below :

  $game_ring_menu = [
  
   # Menu Option 0  eg. Item
   [Vocab::item, Cache::picture('Icon_Items'), "$scene = Scene_Item.new"],
  
   # Menu Option 1  eg. Skill
   [Vocab::skill, Cache::picture('Icon_Skills'), "start_actor_selection",
     "$scene = Scene_Skill.new(@status_window.index)"],
  
   # Menu Option 2  eg. Equip
   [Vocab::equip, Cache::picture('Icon_Equip'), "start_actor_selection",
     "$scene = Scene_Equip.new(@status_window.index)"],
  
   # Menu Option 3  eg. Status
   [Vocab::status, Cache::picture('Icon_Status'), "start_actor_selection",
     "$scene = Scene_Status.new(@status_window.index)"],
  
   #---------------------------------------------------#
   #  **      I N S E R T   M O R E   H E R E      **  #
   #---------------------------------------------------#
  
   # Preferably Insert your custom Menu Options Here
   # Otherwise the existing Menu Options will return to wrong point on the Menu
  
   # Menu Option 4  eg. Save
   ["Save Game", Cache::picture('Icon_Save'), "$scene = Scene_File.new(true, false, false)"],
  
   # Menu Option 5  eg. Load
   ["Load Game", Cache::picture('Icon_Load'), "$scene = Scene_File.new(false, false, false)"],
  
   # Menu Option 6  eg. End Game
   [Vocab::game_end, Cache::picture('Icon_End'), "$scene = Scene_End.new"]
  
   ] # <--- Do no Delete This
  
   #===================================================#
   #  **     E N D   C O N F I G U R A T I O N     **  #
   #===================================================#
  end
end
#==============================================================================
# ** Scene_Menu
#------------------------------------------------------------------------------
#  Edited to add Ring Menu
#==============================================================================

class Scene_Menu < Scene_Base
  #--------------------------------------------------------------------------
  # * Alias Listings
  #--------------------------------------------------------------------------
  alias initialize_original initialize
  alias start_selection_original start_actor_selection
  alias end_selection_original end_actor_selection
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(menu_index = 0, move = true)
    @move = move
    initialize_original(menu_index)
  end
  #--------------------------------------------------------------------------
  # * Start processing
  #--------------------------------------------------------------------------
  def start
    super
    create_menu_background
    create_command_window
    @gold_window = Window_Gold.new(0, 360)
    @location_window = Window_location.new(0, 0)
  end
  #--------------------------------------------------------------------------
  # * Termination Processing
  #--------------------------------------------------------------------------
  def terminate
    super
    dispose_menu_background
    @command_window.dispose
    @gold_window.dispose
    @status_window.dispose if @status_window
    @location_window.dispose
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    super
    update_menu_background
    @command_window.update
    @gold_window.update
    @status_window.update if @status_window
    @location_window.update
    if @command_window.active
      update_command_selection
    elsif @status_window.active
      update_actor_selection
    end
  end
  #--------------------------------------------------------------------------
  # * Create Command Window
  #--------------------------------------------------------------------------
  def create_command_window
    commands = []
    for i in 0...$game_ring_menu.size
      commands.push($game_ring_menu[i][0])
    end
    icons = []
    for i in 0...$game_ring_menu.size
      icons.push($game_ring_menu[i][1])
    end
    @command_window = Window_RingMenu.new(232, 164, commands, icons, @move, @menu_index)
    if $game_party.members.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
  end
  #--------------------------------------------------------------------------
  # * Create Command Window
  #--------------------------------------------------------------------------
  def create_status_window
    names = []
    chars = []
    for i in 0...$game_party.members.size
      names[i] = $game_party.members[i].name
      chars[i] = $game_party.members[i]
    end
    @status_window = Window_RingMenu.new(255, 200, names, chars, true, $game_party.last_actor_index, true)
  end
  #--------------------------------------------------------------------------
  # * Update Command Selection
  #--------------------------------------------------------------------------
  def update_command_selection
    if Input.trigger?(Input::B)
      Sound.play_cancel
      $scene = Scene_Map.new
    elsif Input.trigger?(Input::C)
      if $game_party.members.size == 0 and @command_window.index < 4
        Sound.play_buzzer
        return
      elsif $game_system.save_disabled and @command_window.index == 4
        Sound.play_buzzer
        return
      end
      Sound.play_decision
      eval($game_ring_menu[@command_window.index][2])
    end
  end
  #--------------------------------------------------------------------------
  # * Start Actor Selection
  #--------------------------------------------------------------------------
  def start_actor_selection
    @command_window.active = false
    @command_window.visible = false
    create_status_window
    if $game_party.last_actor_index < @status_window.item_max
      @status_window.index = $game_party.last_actor_index
    else
      @status_window.index = 0
    end
  end
  #--------------------------------------------------------------------------
  # * End Actor Selection
  #--------------------------------------------------------------------------
  def end_actor_selection
    @command_window.active = true
    @command_window.visible = true
    @status_window.dispose if @status_window
    @status_window = nil
  end
  #--------------------------------------------------------------------------
  # * Update Actor Selection
  #--------------------------------------------------------------------------
  def update_actor_selection
    if Input.trigger?(Input::B)
      Sound.play_cancel
      end_actor_selection
    elsif Input.trigger?(Input::C)
      $game_party.last_actor_index = @status_window.index
      Sound.play_decision
      eval($game_ring_menu[@command_window.index][3])
    end
  end
end

#==============================================================================
# ** Scene_File
#------------------------------------------------------------------------------
#  Edited to return to the menu properly when loading
#==============================================================================

class Scene_File
  alias return_scene_original return_scene
  def return_scene
    if @from_title
      $scene = Scene_Title.new
    elsif @from_event
      $scene = Scene_Map.new
    else
      if @saving
        $scene = Scene_Menu.new($game_ring_menu.size - 3)
      else
        $scene = Scene_Menu.new($game_ring_menu.size - 2)
      end
    end
  end
end

#==============================================================================
# ** Scene_End
#------------------------------------------------------------------------------
#  Edited to return to the menu properly due to loading being added
#==============================================================================

class Scene_End
  alias return_scene_original return_scene
  def return_scene
    $scene = Scene_Menu.new($game_ring_menu.size - 1)
  end
end

#==============================================================================
# ** Window_Location
#------------------------------------------------------------------------------
#  This class shows the current map name.
#==============================================================================

class Window_location < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(x, y)
    super(x, y, 160, (WLH*2)   32)
    self.contents = Bitmap.new(width - 32, height - 32)
    refresh
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    $maps = load_data("Data/MapInfos.rvdata")
    @map_id = $game_map.map_id
    @currmap = $maps[@map_id].name
    self.contents.font.color = system_color
    self.contents.draw_text(0, -4, 128, 32, "Location :")
    self.contents.font.color = normal_color
    self.contents.draw_text(0, -4 WLH, 128, 32, @currmap, 1)
  end
end

#==============================================================================
# ** Window_RingMenu
#------------------------------------------------------------------------------
#  This Window creates a Ring Menu system
#==============================================================================

class Window_RingMenu < Window_Base  
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :index
  attr_reader   :item_max
  #--------------------------------------------------------------------------
  # * Refresh Setup
  #--------------------------------------------------------------------------
  START = 1
  WAIT  = 2
  MOVER = 3
  MOVEL = 4
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(center_x, center_y, commands, items, move = true, index = 0, character = false)
    super(0, 0, 544, 416)
    self.contents = Bitmap.new(width-32, height-32)
    self.opacity = 0
    @move = move
    @char = character
    @startup = STARTUP_FRAMES
    @commands = commands
    @item_max = commands.size
    @index = index
    @items = items
    @disabled = []
    for i in 0...commands.size-1
      @disabled[i] = false
    end
    @cx = center_x
    @cy = center_y
    start_setup
    refresh
  end
  #--------------------------------------------------------------------------
  # * Start Setup
  #--------------------------------------------------------------------------
  def start_setup
    @mode = START
    @steps = @startup
  end
  #--------------------------------------------------------------------------
  # * Disable index
  #     index : item number
  #--------------------------------------------------------------------------
  def disable_item(index)
    @disabled[index] = true
  end
  #--------------------------------------------------------------------------
  # * Determines if is moving
  #--------------------------------------------------------------------------
  def animation?
    return @mode != WAIT
  end
  #--------------------------------------------------------------------------
  # * Determine if cursor is moveable
  #--------------------------------------------------------------------------
  def cursor_movable?
    return false if (not visible or not active)
    return false if (@opening or @closing)
    return false if animation?
    return true
  end
  #--------------------------------------------------------------------------
  # * Move cursor right
  #--------------------------------------------------------------------------
  def cursor_right
    @index -= 1
    @index = @items.size - 1 if @index < 0
    @mode = MOVER
    @steps = MOVING_FRAMES
  end
  #--------------------------------------------------------------------------
  # * Move cursor left
  #--------------------------------------------------------------------------
  def cursor_left
    @index  = 1
    @index = 0 if @index >= @items.size
    @mode = MOVEL
    @steps = MOVING_FRAMES
  end
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    super
    if self.active
      if cursor_movable?
        last_index = @index
        if Input.repeat?(Input::DOWN) or Input.repeat?(Input::RIGHT)
          cursor_right
        end
        if Input.repeat?(Input::UP) or Input.repeat?(Input::LEFT)
          cursor_left
        end
        if @index != last_index
          Sound.play_cursor
        end
      end
      refresh
    end
  end
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh    
    self.contents.clear
    case @mode
    when START
      refresh_start
    when WAIT
      refresh_wait
    when MOVER
      refresh_move(1)
    when MOVEL
      refresh_move(0)
    end
    rect = Rect.new(18, 196, self.contents.width-32, 32)
    self.contents.draw_text(rect, @commands[@index], 1)
  end
  #--------------------------------------------------------------------------
  # * Refresh Start Period
  #--------------------------------------------------------------------------
  def refresh_start
    d1 = 2.0 * Math::PI / @item_max
    d2 = 1.0 * Math::PI / @startup
    for i in 0...@item_max
      j = i - @index
      if @move
        r = RING_R - 1.0 * RING_R * @steps / @startup
        d = d1 * j   d2 * @steps
      else
        r = RING_R
        d = d1 * j
      end
      x = @cx   ( r * Math.sin( d ) ).to_i
      y = @cy - ( r * Math.cos( d ) ).to_i
      draw_item(x, y, i)
    end
    @steps -= 1
    if @steps < 1
      @mode = WAIT
    end
  end
  #--------------------------------------------------------------------------
  # * Refresh Wait Period
  #--------------------------------------------------------------------------
  def refresh_wait
    d = 2.0 * Math::PI / @item_max
    for i in 0...@item_max
      j = i - @index
      x = @cx   ( RING_R * Math.sin( d * j ) ).to_i
      y = @cy - ( RING_R * Math.cos( d * j ) ).to_i
      draw_item(x, y, i)
    end
  end
  #--------------------------------------------------------------------------
  # * Refresh Movement Period
  #--------------------------------------------------------------------------
  def refresh_move( mode )
    d1 = 2.0 * Math::PI / @item_max
    d2 = d1 / MOVING_FRAMES
    d2 *= -1 if mode != 0
    for i in 0...@item_max
      j = i - @index
      d = d1 * j   d2 * @steps
      x = @cx   ( RING_R * Math.sin( d ) ).to_i
      y = @cy - ( RING_R * Math.cos( d ) ).to_i
      draw_item(x, y, i)
    end
    @steps -= 1
    if @steps < 1
      @mode = WAIT
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Item
  #     x     : draw spot x-coordinate
  #     y     : draw spot y-coordinate
  #     index : item number
  #--------------------------------------------------------------------------
  def draw_item(x, y, index)
    if @char
      if @index == index
        draw_character(@items[index].character_name, @items[index].character_index , x, y)
        if @mode == WAIT
          draw_actor_hp_ring(@items[index], @cx, @cy-16, 50, 6, 84, 270, true)
          draw_actor_mp_ring(@items[index], @cx, @cy-16, 50, 6, 84, 180, false)
          draw_actor_exp_ring(@items[index], @cx, @cy-16, 50, 6, 155, 12, false)
        end
      else
        draw_character(@items[index].character_name, @items[index].character_index , x, y, false)
      end
    else
      rect = Rect.new(0, 0, @items[index].width, @items[index].height)
      if @index == index
        self.contents.blt( x, y, @items[index], rect )
        if @disabled[@index]
          self.contents.blt( x, y, ICON_DISABLE, rect )
        end
      else
        self.contents.blt( x, y, @items[index], rect, 128 )
      end
    end
  end
end

#==============================================================================
# ** Window_Base
#------------------------------------------------------------------------------
#  Edited to allow disabled character icons
#==============================================================================

class Window_Base < Window
  #--------------------------------------------------------------------------
  # * Draw Character Graphic
  #--------------------------------------------------------------------------
  def draw_character(character_name, character_index, x, y, enabled = true)
    return if character_name == nil
    bitmap = Cache.character(character_name)
    sign = character_name[/^[\!\$]./]
    if sign != nil and sign.include?('$')
      cw = bitmap.width / 3
      ch = bitmap.height / 4
    else
      cw = bitmap.width / 12
      ch = bitmap.height / 8
    end
    n = character_index
    src_rect = Rect.new((n%4*3 1)*cw, (n/4*4)*ch, cw, ch)
    self.contents.blt(x - cw / 2, y - ch, bitmap, src_rect, enabled ? 255 : 128)
  end
end

Y el otro:

Código:

#==============================================================================
# ** Syvkal's Menu Bars
#------------------------------------------------------------------------------
# by Syvkal
# Version 4.1
# 05-20-08
#==============================================================================
#
#  - INTRODUCTION -
#
#  This system implements a series of Plug 'N' Play Menu Bars
#  The Bars were inspired CogWheel, but all coding was done by me
#   ( Except Wortana's 'gradient_fill_rect' Bug Fix )
#
#------------------------------------------------------------------------------
#
#  - USAGE -
#
#  This system will work as soon as you put it in the Script Editor
#  You can edit the script from the Configuration System
#  However, it has also been made so you can easily make your own bars
#
#       ---------------------------------------------------
#
#  To draw a bar use:
#     draw_custom_gauge
#
#  Followed by:
#     (value, max, x, y, color1, color2, width, height, slanted, up)
#
#     value    : bar calculation value
#     max      : bar max value
#     x        : draw spot x-coordinate
#     y        : draw spot y-coordinate
#     color1   : bar gradient color 1          EITHER Color.new(r,g,b,a)
#     color2   : bar gradient color 2          OR Numeric Text color
#     width    : Width
#     height   : Height
#     slanted  : draw slanted bar
#     vertical : draw bar vertically
#
#       ---------------------------------------------------
#
#  To draw a ring use:
#     draw_custom_ring
#
#  Followed by:
#     (value, max, x, y, color1, color2, radius, height, amount, start, reverse)

#     value   : bar calculation value
#     max     : bar max value
#     x       : draw spot x-coordinate
#     y       : draw spot y-coordinate
#     color1  : bar gradient color 1
#     color2  : bar gradient color 2
#     radius  : distance from center point
#     height  : Height
#     amount  : size of ring   - default 360�
#     start   : start position - max 360�
#     reverse : draw ring in reverse
#  
#------------------------------------------------------------------------------
#
#  - SCRIPTERS USAGE -
#
#  I have added a few extra features to allow scripters to easily use the bars
#  Seeing as the bars can be drawn Normal, Vertical or in a Ring I've added a
#  feature to allow you to turn off the bars when drawing an actors HP, MP etc.
#  When drawing an actors HP etc. simply add 'true' on the end. Like this:
#       draw_actor_hp(actor, x, y, width, true)
#
#  I've also separated the different bars so they're easier to draw
#
#   draw_actor_hp_gauge(actor, x, y, width)         Will draw a normal bar
#   draw_actor_hp_gauge(actor, x, y, width, true)   Will draw a vertical bar
#   draw_actor_hp_ring(actor, x, y, radius, height, amount, start)
#                                                   Will draw a ring
#
#------------------------------------------------------------------------------
#
#  - SCRIPT CALLS -
#
#  There are no script calls necessary to enable this script
#  However, you can change any of the constants in game if you wish
#  This can be done by the Script Call Funtion in an event
#
#  For example:
#      COG::HPMPSLANT = true
#
#  Will make the HP and MP bars Slant
#  And setting it to false will turn them back to normal
#
#==============================================================================
module BAR
   #===================================================#
   #  **  C O N F I G U R A T I O N   S Y S T E M  **  #
   #===================================================#
  
  # Parameter Max Value
    P_MAX = 500
 # The system uses a 'rate' feature. It is set when drawing a bar
 # The 'rate' is how much the bar is filled as a decimal (max : 1)
 # This is used to enable color change as the bar decreased in amount
    $rate = 0    # Don't touch this
 # The system uses a series of CONSTANTS that can be edited here
 # They control the basic gauge colors and the manner the gauge is filled:

  # Gauge Border Colors
    COLOR1 = Color.new(0, 0, 0, 192)         # Outer Border
    COLOR2 = Color.new(255, 255, 192, 192)   # Inner Border
  # Gauge Empty filler
    COLOR3 = Color.new(0, 0, 0, 12)          # Half of Inner Shading
    COLOR4 = Color.new(64, 0, 0, 92)         # Half of Inner Shading
  # Gauge Settings
    EMPTY  = false   # EMPTY  gauge (false - Side : true - Vertical)
    FILLER = false   # FILLER gauge (false - Side : true - Vertical)
  # Border Settings    -    Applies only to standard bars
    CORNER = false                            # Remove corners?
    
 # The Parameter colors can be text colors taken from the windowskin or
 # colors like above. You don't need set your own 'rate' functions
 # it does it for you
  # Parameter Gauge Color1
    ATKCOLOR1 = 2
    DEFCOLOR1 = 17
    SPICOLOR1 = 30
    AGICOLOR1 = 12
  # Parameter Gauge Color2
    ATKCOLOR2 = 20
    DEFCOLOR2 = 21
    SPICOLOR2 = 31
    AGICOLOR2 = 4
  
 # The system has been made to use a series of SWITCHES that can be edited here
 # They control whether certain Bars are Normal or Slanted:
 
    HPMPSLANT  = false    # Slanted HP and MP Bars?
    EXPSLANT   = false    # Slanted Exp Bars?
    PARSLANT   = false    # Slanted Parameter Bars?
    DVVLBSLANT = true     # Slanted Limit Break Bars?
    
   #===================================================#
   #  ** C O M P L E X   C O N F I G U R A T I O N **  #
   #===================================================#
    
 # The system allows you to edit the main gauge colous from here
 # Functions had to be used instead of Constants so the $rate feature still works
 # Edit only if you know what you're doing:

  def self::hpcolor1 # HP Guage Color1
    return Color.new(80 - 24 * $rate, 80 * $rate, 14 * $rate, 192)
  end
  def self::hpcolor2 # HP Guage Color2
    return Color.new(240 - 72 * $rate, 240 * $rate, 62 * $rate, 192)
  end
  def self::mpcolor1 # MP Guage Color1
    return Color.new(14 * $rate, 80 - 24 * $rate, 80 * $rate, 192)
  end
  def self::mpcolor2 # MP Guage Color2
    return Color.new(62 * $rate, 240 - 72 * $rate, 240 * $rate, 192)
  end
  def self::expcolor1 # EXP Guage Color1
    Color.new(80 * $rate, 80 - 80 * $rate ** 2, 80 - 80 * $rate, 192)
  end
  def self::expcolor2 # EXP Guage Color2
    Color.new(240 * $rate, 240 - 240 * $rate ** 2, 240 - 240 * $rate, 192)
  end  
   #===================================================#
   #  **     E N D   C O N F I G U R A T I O N     **  #
   #===================================================#
end
#==============================================================================
# ** Game_Actor
#------------------------------------------------------------------------------
#  Added EXP and Next Level EXP for numeric for calculations
#==============================================================================
class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # * Get EXP - numeric for calculations
  #--------------------------------------------------------------------------  
  def now_exp
    return @exp - @exp_list[@level]
  end
  #--------------------------------------------------------------------------
  # * Get Next Level EXP - numeric for calculations
  #--------------------------------------------------------------------------
  def next_exp
    return @exp_list[@level 1] > 0 ? @exp_list[@level 1] - @exp_list[@level] : 0
  end
end
#==============================================================================
# ** Window_Base
#------------------------------------------------------------------------------
#  Added the 'Draw' functions for each gauge
#==============================================================================
class Window_Base < Window
  #--------------------------------------------------------------------------
  # * Includes The BAR Module
  #--------------------------------------------------------------------------  
  include BAR
  #--------------------------------------------------------------------------
  # * Alias Listings
  #--------------------------------------------------------------------------  
  alias draw_actor_parameter_original draw_actor_parameter
  #--------------------------------------------------------------------------
  # * Draw HP gauge
  #     vertical : draw bar vertically
  #--------------------------------------------------------------------------
  def draw_actor_hp_gauge(actor, x, y, width = 120, vertical = false)
    $rate = actor.hp.to_f / actor.maxhp
    gw = width * actor.hp / actor.maxhp
    w = vertical ? 6 : width; h = vertical ? width : 6
    HPMPSLANT ? self.contents.cogwheel_fill_slant(x, y   WLH - 8, gw, w, h, BAR::hpcolor1, BAR::hpcolor2, vertical) :
    self.contents.cogwheel_fill_rect(x, y   WLH - 8, gw, w, h, BAR::hpcolor1, BAR::hpcolor2, vertical)
  end
  #--------------------------------------------------------------------------
  # * Draw MP gauge
  #     vertical : draw bar vertically
  #--------------------------------------------------------------------------
  def draw_actor_mp_gauge(actor, x, y, width = 120, vertical = false)
    $rate = actor.mp.to_f / [actor.maxmp, 1].max
    gw = width * actor.mp / [actor.maxmp, 1].max
    w = vertical ? 6 : width; h = vertical ? width : 6
    HPMPSLANT ? self.contents.cogwheel_fill_slant(x, y   WLH - 8, gw, w, h, BAR::mpcolor1, BAR::mpcolor2, vertical) :
    self.contents.cogwheel_fill_rect(x, y   WLH - 8, gw, w, h, BAR::mpcolor1, BAR::mpcolor2, vertical)
  end
  #--------------------------------------------------------------------------
  # * Draw Exp gauge
  #     actor    : actor
  #     x        : draw spot x-coordinate
  #     y        : draw spot y-coordinate
  #     width    : Width
  #     vertical : draw bar vertically
  #--------------------------------------------------------------------------
  def draw_actor_exp_gauge(actor, x, y, width = 170, vertical = false)
    $rate = actor.now_exp.to_f / [actor.next_exp, 1].max
    gw = width * actor.now_exp / [actor.next_exp, 1].max
    w = vertical ? 6 : width; h = vertical ? width : 6
    EXPSLANT ? self.contents.cogwheel_fill_slant(x, y   WLH - 8, gw, w, h, BAR::expcolor1, BAR::expcolor2, vertical) :
    self.contents.cogwheel_fill_rect(x, y   WLH - 8, gw, w, h, BAR::expcolor1, BAR::expcolor2, vertical)
  end
  #--------------------------------------------------------------------------
  # * Draw Parameters
  #     hide_bar : draw Parameters without gauge
  #--------------------------------------------------------------------------
  def draw_actor_parameter(actor, x, y, type, hide_bar = false)
    hide_bar ? nil : draw_actor_parameter_gauge(actor, x, y, type)
    draw_actor_parameter_original(actor, x, y, type)
  end
  #--------------------------------------------------------------------------
  # * Draw Parameters gauge
  #     actor    : actor
  #     x        : draw spot x-coordinate
  #     y        : draw spot y-coordinate
  #     type     : Type of parameters (0-3)
  #     width    : Width
  #     vertical : draw bar vertically
  #--------------------------------------------------------------------------
  def draw_actor_parameter_gauge(actor, x, y, type, width = 160, vertical = false)
    case type
    when 0
      e1 = actor.atk
      gc1 = ATKCOLOR1.is_a?(Integer) ? text_color(ATKCOLOR1) : ATKCOLOR1
      gc2 = ATKCOLOR2.is_a?(Integer) ? text_color(ATKCOLOR2) : ATKCOLOR2
    when 1
      e1 = actor.def
      gc1 = DEFCOLOR1.is_a?(Integer) ? text_color(DEFCOLOR1) : DEFCOLOR1
      gc2 = DEFCOLOR2.is_a?(Integer) ? text_color(DEFCOLOR2) : DEFCOLOR2
    when 2
      e1 = actor.spi
      gc1 = SPICOLOR1.is_a?(Integer) ? text_color(SPICOLOR1) : SPICOLOR1
      gc2 = SPICOLOR2.is_a?(Integer) ? text_color(SPICOLOR2) : SPICOLOR2
    when 3
      e1 = actor.agi
      gc1 = AGICOLOR1.is_a?(Integer) ? text_color(AGICOLOR1) : AGICOLOR1
      gc2 = AGICOLOR2.is_a?(Integer) ? text_color(AGICOLOR2) : AGICOLOR2
    end
    e2 = P_MAX
    rate = [e1.to_f / e2.to_f, 1].min
    gw = width * [e1.to_f / e2.to_f, 1].min
    r = gc2.red * rate
    g = (gc2.green - 72) * rate
    b = gc2.blue  * rate
    a = gc2.alpha
    w = vertical ? 6 : width; h = vertical ? width : 6
    PARSLANT ? self.contents.cogwheel_fill_slant(x, y   WLH - 8, gw, w, h, gc1, Color.new(r, g, b, a), vertical) :
    self.contents.cogwheel_fill_rect(x, y   WLH - 8, gw, w, h, gc1, Color.new(r, g, b, a), vertical)
  end
  #--------------------------------------------------------------------------
  # * Draw Custom gauge
  #     value    : bar calculation value
  #     max      : bar max value
  #     x        : draw spot x-coordinate
  #     y        : draw spot y-coordinate
  #     color1   : bar gradient color 1
  #     color2   : bar gradient color 2
  #     width    : Width
  #     height   : Height
  #     slanted  : draw slanted bar
  #     vertical : draw bar vertically
  #--------------------------------------------------------------------------
  def draw_custom_gauge(value, max, x, y, color1, color2, width=120, height=6, slanted = false, vertical = false)
    rate = [value.to_f / max.to_f, 1].min
    gw = width * [value.to_f / max.to_f, 1].min
    gc1 = color1.is_a?(Integer) ? text_color(color1) : color1
    gc2 = color2.is_a?(Integer) ? text_color(color2) : color2
    r = gc2.red * rate
    g = (gc2.green - 72) * rate
    b = gc2.blue  * rate
    a = gc2.alpha
    w = vertical ? 6 : width; h = vertical ? width : 6
    slanted ? self.contents.cogwheel_fill_slant(x, y   WLH - 8, gw, w, h, gc1, Color.new(r, g, b, a), vertical) :
    self.contents.cogwheel_fill_rect(x, y   WLH - 8, gw, w, h, gc1, Color.new(r, g, b, a), vertical)
  end
  #--------------------------------------------------------------------------
  # * Draw Limit Break gauge
  #     vertical : draw bar vertically
  #--------------------------------------------------------------------------
  def draw_actor_lb(actor, x, y, width = 120, vertical = false)
    return unless actor.lb_gauge_visible?
    st1 = lb_gauge_normal_start_color; st2 = lb_gauge_max_start_color
    ed1 = lb_gauge_normal_end_color; ed2 = lb_gauge_max_end_color
    rate = actor.limitbreak.to_f / [LB_MAX, 1].max
    gw = width * actor.limitbreak / LB_MAX
    gc1 = (gw == width ? st2 : Color.new(st1.red,st1.green-(10*rate),st1.blue-(10*rate), 192))
    gc2 = (gw == width ? ed2 : Color.new(ed1.red,ed1.green-(10*rate),ed1.blue-(10*rate), 192))
    w = vertical ? 6 : width; h = vertical ? width : 6
    DVVLBSLANT ? self.contents.cogwheel_fill_slant(x, y   WLH - 8, gw, w, h, gc1, gc2, vertical) :
    self.contents.cogwheel_fill_rect(x, y   WLH - 8, gw, w, h, gc1, gc2, vertical)
  end  
  #--------------------------------------------------------------------------
  # * Draw HP gauge ring
  #     actor   : actor
  #     x       : draw spot x-coordinate
  #     y       : draw spot y-coordinate
  #     radius  : distance from center point
  #     height  : Height
  #     amount  : size of ring   - default 360�
  #     start   : start position - max 360�
  #     reverse : draw ring in reverse
  #--------------------------------------------------------------------------
  def draw_actor_hp_ring(actor, x, y, radius, height, amount = 360, start = 0, reverse = false)
    $rate = actor.hp.to_f / actor.maxhp
    gw = amount * actor.hp / actor.maxhp
    self.contents.cogwheel_fill_ring(x, y, gw, radius, height, BAR::hpcolor1, BAR::hpcolor2, amount, start, reverse)
  end
  #--------------------------------------------------------------------------
  # * Draw MP gauge ring
  #     actor   : actor
  #     x       : draw spot x-coordinate
  #     y       : draw spot y-coordinate
  #     radius  : distance from center point
  #     height  : Height
  #     amount  : size of ring   - default 360�
  #     start   : start position - max 360�
  #     reverse : draw ring in reverse
  #--------------------------------------------------------------------------
  def draw_actor_mp_ring(actor, x, y, radius, height, amount = 360, start = 0, reverse = false)
    $rate = actor.mp.to_f / [actor.maxmp, 1].max
    gw = amount * actor.mp / [actor.maxmp, 1].max
    self.contents.cogwheel_fill_ring(x, y, gw, radius, height, BAR::mpcolor1, BAR::mpcolor2, amount, start, reverse)
  end
  #--------------------------------------------------------------------------
  # * Draw Exp gauge ring
  #     actor   : actor
  #     x       : draw spot x-coordinate
  #     y       : draw spot y-coordinate
  #     radius  : distance from center point
  #     height  : Height
  #     amount  : size of ring   - default 360�
  #     start   : start position - max 360�
  #     reverse : draw ring in reverse
  #--------------------------------------------------------------------------
  def draw_actor_exp_ring(actor, x, y, radius, height, amount = 360, start = 0, reverse = false)
    $rate = actor.now_exp.to_f / [actor.next_exp, 1].max
    gw = amount * actor.now_exp / [actor.next_exp, 1].max
    self.contents.cogwheel_fill_ring(x, y, gw, radius, height, BAR::expcolor1, BAR::expcolor2, amount, start, reverse)
  end
  #--------------------------------------------------------------------------
  # * Draw Custom gauge ring
  #     value   : bar calculation value
  #     max     : bar max value
  #     x       : draw spot x-coordinate
  #     y       : draw spot y-coordinate
  #     color1  : bar gradient color 1
  #     color2  : bar gradient color 2
  #     radius  : distance from center point
  #     height  : Height
  #     amount  : size of ring   - default 360�
  #     start   : start position - max 360�
  #     reverse : draw ring in reverse
  #--------------------------------------------------------------------------
  def draw_custom_ring(value, max, x, y, color1, color2, radius, height, amount = 360, start = 0, reverse = false)
    rate = [value.to_f / max.to_f, 1].min
    gw = amount * [value.to_f / max.to_f, 1].min
    gc1 = color1.is_a?(Integer) ? text_color(color1) : color1
    gc2 = color2.is_a?(Integer) ? text_color(color2) : color2
    r = gc2.red * rate
    g = (gc2.green - 72) * rate
    b = gc2.blue  * rate
    a = gc2.alpha
    self.contents.cogwheel_fill_ring(x, y, gw, radius, height, gc1, Color.new(r, g, b, a), amount, start, reverse)
  end
  #--------------------------------------------------------------------------
  # * Draw HP
  #     hide_bar : draw Parameters without gauge
  #--------------------------------------------------------------------------
  def draw_actor_hp(actor, x, y, width = 120, hide_bar = false)
    hide_bar ? nil : draw_actor_hp_gauge(actor, x, y, width)
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 30, WLH, Vocab::hp_a)
    self.contents.font.color = hp_color(actor)
    last_font_size = self.contents.font.size
    xr = x   width
    if width < 120
      self.contents.draw_text(xr - 44, y, 44, WLH, actor.hp, 2)
    else
      self.contents.draw_text(xr - 99, y, 44, WLH, actor.hp, 2)
      self.contents.font.color = normal_color
      self.contents.draw_text(xr - 55, y, 11, WLH, "/", 2)
      self.contents.draw_text(xr - 44, y, 44, WLH, actor.maxhp, 2)
    end
  end
  #--------------------------------------------------------------------------
  # * Draw MP
  #     hide_bar : draw Parameters without gauge
  #--------------------------------------------------------------------------
  def draw_actor_mp(actor, x, y, width = 120, hide_bar = false)
    hide_bar ? nil : draw_actor_mp_gauge(actor, x, y, width)
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 30, WLH, Vocab::mp_a)
    self.contents.font.color = mp_color(actor)
    last_font_size = self.contents.font.size
    xr = x   width
    if width < 120
      self.contents.draw_text(xr - 44, y, 44, WLH, actor.mp, 2)
    else
      self.contents.draw_text(xr - 99, y, 44, WLH, actor.mp, 2)
      self.contents.font.color = normal_color
      self.contents.draw_text(xr - 55, y, 11, WLH, "/", 2)
      self.contents.draw_text(xr - 44, y, 44, WLH, actor.maxmp, 2)
    end
  end
  #--------------------------------------------------------------------------
  # * Draw Exp
  #     actor    : actor
  #     x        : draw spot x-coordinate
  #     y        : draw spot y-coordinate
  #     width    : Width
  #     hide_bar : draw Parameters without gauge
  #--------------------------------------------------------------------------
  def draw_actor_exp(actor, x, y, width = 170, hide_bar = false)
    hide_bar ? nil : draw_actor_exp_gauge(actor, x, y, width)
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 45, WLH, "Exp")
    self.contents.font.color = normal_color
    xr = x   width
    if width < 170
      self.contents.draw_text(xr - 60, y, 60, WLH,  actor.next_rest_exp_s, 2)  
    else
      self.contents.draw_text(xr - 131, y, 60, WLH, actor.exp_s, 2)
      self.contents.draw_text(xr - 71, y, 11, WLH, "/", 2)
      self.contents.draw_text(xr - 60, y, 60, WLH, actor.next_exp_s, 2)
    end
  end
end
#==============================================================================
# ** Window_SkillStatus
#------------------------------------------------------------------------------
#  Edited so te Bars don't cut off
#==============================================================================
class Window_SkillStatus < Window_Base
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    draw_actor_name(@actor, 4, 0)
    draw_actor_level(@actor, 140, 0)
    draw_actor_hp(@actor, 238, 0)
    draw_actor_mp(@actor, 390, 0)
  end
end
#==============================================================================
# ** Bitmap
#------------------------------------------------------------------------------
#  Added gauge Calculations
#==============================================================================
class Bitmap
  #--------------------------------------------------------------------------
  # * Includes The BAR Module
  #--------------------------------------------------------------------------  
  include BAR
  #--------------------------------------------------------------------------
  # * Wortana's 'gradient_fill_rect' Bug Fix
  #--------------------------------------------------------------------------
  alias gradient_original gradient_fill_rect unless method_defined?('gradient_original')
  def gradient_fill_rect(*args)
    args.pop if !args.last if args.size == 4 || 7 and !args.last
    gradient_original(*args)
  end
  #--------------------------------------------------------------------------
  # * CogWheel Style Fill of Rect
  #--------------------------------------------------------------------------
  def cogwheel_fill_rect(x, y, gw, width, height, gc1, gc2, up = false)
    rect_border(x-2, y-2, width 4, height 4, COLOR1, CORNER)
    rect_border(x-1, y-1, width 2, height 2, COLOR2, CORNER)
    gradient_fill_rect(x, y, width, height, COLOR3, COLOR4, EMPTY)
    gradient_fill_rect(x, y, up ? width : gw, up ? gw : height, gc1, gc2, FILLER)
  end
  #--------------------------------------------------------------------------
  # * CogWheel Style Fill of Slanted Rect
  #--------------------------------------------------------------------------
  def cogwheel_fill_slant(x, y, gw, width, height, gc1, gc2, up = false)
    bgx = up ? 2 : 4; bdx = up ? 1 : 2
    bgy = up ? 4 : 2; bdy = up ? 2 : 1
    bgw = up ? 4 : 8; bdw = up ? 2 : 4
    bgh = up ? 8 : 4; bdh = up ? 4 : 2
    slant_border(x-bgx, y-bgy, width bgw, height bgh, COLOR1, up)
    slant_border(x-bdx, y-bdy, width bdw, height bdh, COLOR2, up)
    gradient_fill_slant(x, y, width, height, COLOR3, COLOR4, EMPTY, up)
    gradient_fill_slant(x, y,up ? width : gw,up ? gw : height, gc1, gc2, FILLER, up)
  end
  #--------------------------------------------------------------------------
  # * CogWheel Style Fill of Ring
  #--------------------------------------------------------------------------
  def cogwheel_fill_ring(x, y, gw, radius, height, gc1, gc2, amount = 360, start = 0, reverse = false)
    fill_ring(x-2, y-2, radius, height 4, COLOR1, amount, start, reverse)
    fill_ring(x-1, y-1, radius, height 2, COLOR2, amount, start, reverse)
    if amount >= 220
      gradient_fill_ring(x, y, radius, height, COLOR3, COLOR4, [amount/2, 180].min, start, reverse)
      gradient_fill_ring(x, y, radius, height, COLOR4, COLOR3, [amount/2, 180].min, start (amount/2), reverse)
    else
      gradient_fill_ring(x, y, radius, height, COLOR3, COLOR4, [amount, 360].min, start, reverse)
    end
    if gw >= 220
      gw1 = amount/2; gw2 = gw / 2
      gradient_fill_ring(x, y, radius, height, gc1, gc2, gw1, start, reverse)
      gradient_fill_ring(x, y, radius, height, gc2, gc1, gw2, start  (amount/2), reverse)
    else
      gradient_fill_ring(x, y, radius, height, gc1, gc2, gw, start, reverse)
    end
  end
  #--------------------------------------------------------------------------
  # * Fill of Border
  #--------------------------------------------------------------------------
  def rect_border(x, y, width, height, gc1, edge = false)
    fill_rect(x   (edge ? 1 : 0), y, width - (edge ? 2 : 0), 2, gc1)
    fill_rect(x   (edge ? 1 : 0), y (height-2), width - (edge ? 2 : 0), 2, gc1)
    fill_rect(x, y 1, 2, height-2, gc1)
    fill_rect(x  (width-2), y 1, 2, height-2, gc1)
  end
  #--------------------------------------------------------------------------
  # * Gradient Fill of Slanted Rect
  #--------------------------------------------------------------------------
  def gradient_fill_slant(x, y, width, height, gc1, gc2, vertical = false, up = false)
    if up
      for i in 1..width
        if vertical
          gradient_fill_rect(x   width - i, y i 1, 1, (height-2)-width, gc1, gc2, vertical)
        else
          color = get_gradient_pixel(gc1, gc2, width, i)
          fill_rect(x   width - i, y i 1, 1, (height-2)-width, color)
        end
      end
    else
      for i in 1..height
        if vertical
          color = get_gradient_pixel(gc1, gc2, height, i)
          fill_rect(x i 1, y   height - i, (width-2)-height, 1, color)
        else
          gradient_fill_rect(x i 1, y   height - i, (width-2)-height, 1, gc1, gc2)
        end
      end
    end
  end  
  #--------------------------------------------------------------------------
  # * Fill of Slanted Rect
  #--------------------------------------------------------------------------
  def fill_slant(x, y, width, height, gc1, up = false)
    oh = up ? width : height
    for i in 1..oh
      if up
        fill_rect(x   width -i, y i, 1, height-width, gc1)
      else
        fill_rect(x i, y   height -i, width-height, 1, gc1)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Fill of Slanted Border
  #--------------------------------------------------------------------------
  def slant_border(x, y, width, height, gc1, up = false)
    oh = up ? width : height
    for i in 1..oh-2
      if up
        fill_rect(x   width-1 -i, y ((height-1)-width) i, 1, 2, gc1)
        fill_rect(x   width-1 -i, y 1 i, 1, 2, gc1)
        fill_rect(x   width-1, y 1, 1, height-width, gc1)
        fill_rect(x, y width, 1, height-width, gc1)
      else
        fill_rect(x ((width-1)-height) i, y   height-1 -i, 2, 1, gc1)
        fill_rect(x 1 i, y   height-1 -i, 2, 1, gc1)
        fill_rect(x 1, y   height -1, width-height, 1, gc1)
        fill_rect(x height, y, width-height, 1, gc1)
      end
    end
  end
  #--------------------------------------------------------------------------
  # * Fill of Ring
  #--------------------------------------------------------------------------
  def fill_ring(ox, oy, radius, height, gc1, amount = 360, start = 0, reverse = false)
    d = 2.0 * Math::PI / 360
    for i in 1..[amount, 360].min
      s = i   start
      if reverse
        x = ox   ( radius * Math.sin( d * s ) ).to_i
        y = oy - ( radius * Math.cos( d * s ) ).to_i
      else
        x = ox - ( radius * Math.cos( d * s ) ).to_i
        y = oy   ( radius * Math.sin( d * s ) ).to_i
      end
      fill_rect(x, y, height, height, gc1)
    end
  end
  #--------------------------------------------------------------------------
  # * Gradient Fill of Ring
  #--------------------------------------------------------------------------
  def gradient_fill_ring(ox, oy, radius, height, gc1, gc2, amount = 360, start = 0, reverse = false)
    d = 2.0 * Math::PI / 360
    for i in 1..amount
      s = i   start
      if reverse
        x = ox   ( radius * Math.sin( d * s ) ).to_i
        y = oy - ( radius * Math.cos( d * s ) ).to_i
      else
        x = ox - ( radius * Math.cos( d * s ) ).to_i
        y = oy   ( radius * Math.sin( d * s ) ).to_i
      end
      color = get_gradient_pixel(gc1, gc2, amount, i)
      fill_rect(x, y, height, height, color)
    end
  end
  #--------------------------------------------------------------------------
  # * Get Pixel Color for Gradient Fill
  #--------------------------------------------------------------------------
  def get_gradient_pixel(gc1, gc2, amount, i)
    red = gc1.red * (amount - i) / amount   gc2.red * i / amount
    green = gc1.green * (amount - i) / amount   gc2.green * i / amount
    blue = gc1.blue * (amount - i) / amount   gc2.blue * i / amount
    alpha = gc1.alpha * (amount - i) / amount   gc2.alpha * i / amount
    return Color.new(red, green, blue, alpha)
  end
end

Espero que les guste. Salu2
avatar
JapoZero
PJ Principal
PJ Principal

Masculino
Chile
RPG Maker : Ace
Mensajes : 653
Monedas : 3510
Reputación : 261
Edad : 18
Localización : Chile

Volver arriba Ir abajo

Re: [VX]Menu Anillo

Mensaje por Sensei el Dom Ago 05, 2018 9:31 pm

Buen dia, eh estado revisando y tiene varios errores en la sintaxis... arregle el primero.. (le faltaban algunos + y , 
y en el 2 ya ando atorado de la linea 551 para abajo...no se si salgan mas :P

Sensei
PJ de Relleno
PJ de Relleno

México
RPG Maker : Vx
Mensajes : 2
Monedas : 2
Reputación : 0

Volver arriba Ir abajo

Volver arriba

- Temas similares

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