Ring menu
Script pour RPG Maker VX
Ecrit par Syvkal
Vous aurez besoin d'images pour faire fonctionner le script, une appelée Icon_Disable plus celles dont le nom est indiqué à partir de la ligne 40.
Par exemple :        
Les endroits où il est possible de configurer des choses sont indiqués dans le script.
Portion de code:
#==============================================================================
# ** 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[0])
end
icons = []
for i in 0...$game_ring_menu.size
icons.push($game_ring_menu[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 = $game_party.members.name
chars = $game_party.members
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 = 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
#==============================================================================
# ** 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
|
| 
|
Zeus81 - posté le 28/09/2010 à 05:04:31. (8687 messages postés)
|
Ero-Maker | Y'a pas de screen ?
=>[] |
The Ark of Gladoria - Mes scripts et autres - Oniro Paradise - Gemini - Fan de Némausus & Ddken |
|
Benku - posté le 28/09/2010 à 10:08:03. (2831 messages postés)
|
Benku, le prince des ténèbres ! | Ouais pas mal, mais faisable en event  /summon kilam |
Comme tout ceux qui vivent des heures si sombres mais ce n'est pas à eux de décider, tout ce que vous avez à décider, c'est quoi faire du temps qui vous est imparti. |
|
trophe - posté le 28/09/2010 à 18:11:28. (136 messages postés)
|
les pouvoirs de l'infini... | C'est toi qui l'a créé, ce script ?
je ne le pense pas... |
forum LPDI : http://lpdileforumofficiel.forumgratuit/ - chaîne youtube : http://www.youtube.com/user/trophe80 |
|
Lufia - posté le 28/09/2010 à 18:25:31. (5792 messages postés)
|
Un Oniromancien. PVs 1, Attaque 0, Défense 0. | C'est un script de Syvkal, c'est écrit. C'est pas lui qui l'a proposé sur le site, mais je devrais même pas accepter des trucs qui ne sont pas proposés par leurs auteurs, donc j'ai au moins crédité sous le bon nom. |
Une signature ? Pour quoi faire ? |
|
|
(très) jeune maker | benku=> ben j'aimerais voir ça! |
j'ai la flemme d'écrire une signature... |
|
deltaone - posté le 03/01/2012 à 22:15:05. (29 messages postés)
|
| Bonsoir a toutes et a tous, désoler si je remonte un ancient topic mais j'ai un petit probleme avec ce script ??
quant je lance le jeu et que je veut ouvrir le menu j'ai cette erreur :
Script 'Ring Menu' line 989: NoMethodError occured.
undefinited methode 'width' for#<array:0x299afc0>
ceci sur un nouveau projet ou je n'ai ajouter que le script des 8 direction et scene title screen.
PS : j'avais deja fait un projet avec rmxp ^^ merci a vous
je m'auto répond, j'ai régler mon problème en utilisant un autre script ring menu trouver sur un autre site | 
|
