+- Save-Point (https://www.save-point.org)
+-- Forum: Archives (https://www.save-point.org/forum-105.html)
+--- Forum: Creation Asylum Archives (https://www.save-point.org/forum-90.html)
+---- Forum: Scripts & Code Snippets (https://www.save-point.org/forum-92.html)
+----- Forum: RPG Maker XP Code (https://www.save-point.org/forum-93.html)
+----- Thread: A CMS (/thread-6875.html)
A CMS - Split - 07-09-2006
This is a locked, single-post thread from Creation Asylum. Archived here to prevent its loss.
No support is given. If you are the owner of the thread, please contact administration.
No support is given. If you are the owner of the thread, please contact administration.
I am entering this in a contest on another forum. I need some feedback on this CMS I am making. What I would need to add take out stuff like that.
Credits-
Ultrapokemaniac - Scrolling Window Thing
CogWheel - Bars
Code
Code:
#==============================================================================
# ** Scene_Menu
#------------------------------------------------------------------------------
# This class performs menu screen processing.
#==============================================================================
class Scene_Menu
#--------------------------------------------------------------------------
# * Object Initialization
# menu_index : command cursor's initial position
#--------------------------------------------------------------------------
def initialize(menu_index = 0)
@menu_index = menu_index
end
#--------------------------------------------------------------------------
# * Main Processing
#--------------------------------------------------------------------------
def main
# Make command window
s1 = $data_system.words.item
s2 = $data_system.words.skill
s3 = $data_system.words.equip
s4 = "Status"
s5 = "Save"
s6 = "End Game"
@command_window = Scrolling_Command.new("horz", 80, [s1, s2, s3, s4, s5, s6], 1, @menu_index)
@command_window.index = @menu_index
# If number of party members is 0
if $game_party.actors.size == 0
# Disable items, skills, equipment, and status
@command_window.disable_item(0)
@command_window.disable_item(1)
@command_window.disable_item(2)
@command_window.disable_item(3)
end
# If save is forbidden
if $game_system.save_disabled
# Disable save
@command_window.disable_item(4)
end
# Make play time window
@playtime_window = Window_PlayTime.new
@playtime_window.x = 320
@playtime_window.y = 380
# Make steps window
@steps_window = Window_Location.new
@steps_window.x = 0
@steps_window.y = 380
# Make gold window
@gold_window = Window_Gold.new
@gold_window.x = 360
@gold_window.y = 0
# Make status window
@status_window = Window_MenuStatus.new
@status_window.x = 0
@status_window.y = 80
# Execute transition
Graphics.transition
# Main loop
loop do
# Update game screen
Graphics.update
# Update input information
Input.update
# Frame update
update
# Abort loop if screen is changed
if $scene != self
break
end
end
# Prepare for transition
Graphics.freeze
# Dispose of windows
@command_window.dispose
@playtime_window.dispose
@steps_window.dispose
@gold_window.dispose
@status_window.dispose
end
#--------------------------------------------------------------------------
# * Frame Update
#--------------------------------------------------------------------------
def update
# Update windows
@command_window.update
@playtime_window.update
@steps_window.update
@gold_window.update
@status_window.update
# If command window is active: call update_command
if @command_window.active
update_command
return
end
# If status window is active: call update_status
if @status_window.active
update_status
return
end
end
#--------------------------------------------------------------------------
# * Frame Update (when command window is active)
#--------------------------------------------------------------------------
def update_command
# If B button was pressed
if Input.trigger?(Input::B)
# Play cancel SE
$game_system.se_play($data_system.cancel_se)
# Switch to map screen
$scene = Scene_Map.new
return
end
# If C button was pressed
if Input.trigger?(Input::C)
# If command other than save or end game, and party members = 0
if $game_party.actors.size == 0 and @command_window.index < 4
# Play buzzer SE
$game_system.se_play($data_system.buzzer_se)
return
end
# Branch by command window cursor position
case @command_window.index
when 0 # item
# Play decision SE
$game_system.se_play($data_system.decision_se)
# Switch to item screen
$scene = Scene_Item.new
when 1 # skill
# Play decision SE
$game_system.se_play($data_system.decision_se)
# Make status window active
@command_window.active = false
@status_window.active = true
@status_window.index = 0
when 2 # equipment
# Play decision SE
$game_system.se_play($data_system.decision_se)
# Make status window active
@command_window.active = false
@status_window.active = true
@status_window.index = 0
when 3 # status
# Play decision SE
$game_system.se_play($data_system.decision_se)
# Make status window active
@command_window.active = false
@status_window.active = true
@status_window.index = 0
when 4 # save
# If saving is forbidden
if $game_system.save_disabled
# Play buzzer SE
$game_system.se_play($data_system.buzzer_se)
return
end
# Play decision SE
$game_system.se_play($data_system.decision_se)
# Switch to save screen
$scene = Scene_Save.new
when 5 # end game
# Play decision SE
$game_system.se_play($data_system.decision_se)
# Switch to end game screen
$scene = Scene_End.new
end
return
end
end
#--------------------------------------------------------------------------
# * Frame Update (when status window is active)
#--------------------------------------------------------------------------
def update_status
# If B button was pressed
if Input.trigger?(Input::B)
# Play cancel SE
$game_system.se_play($data_system.cancel_se)
# Make command window active
@command_window.active = true
@status_window.active = false
@status_window.index = -1
return
end
# If C button was pressed
if Input.trigger?(Input::C)
# Branch by command window cursor position
case @command_window.index
when 1 # skill
# If this actor's action limit is 2 or more
if $game_party.actors[@status_window.index].restriction >= 2
# Play buzzer SE
$game_system.se_play($data_system.buzzer_se)
return
end
# Play decision SE
$game_system.se_play($data_system.decision_se)
# Switch to skill screen
$scene = Scene_Skill.new(@status_window.index)
when 2 # equipment
# Play decision SE
$game_system.se_play($data_system.decision_se)
# Switch to equipment screen
$scene = Scene_Equip.new(@status_window.index)
when 3 # status
# Play decision SE
$game_system.se_play($data_system.decision_se)
# Switch to status screen
$scene = Scene_Status.new(@status_window.index)
end
return
end
end
end
#==============================================================================
# ** Window_MenuStatus
#------------------------------------------------------------------------------
# This window displays party member status on the menu screen.
#==============================================================================
class Window_MenuStatus < Window_Selectable
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize
super(0, 0, 640, 300)
self.contents = Bitmap.new(width - 32, height - 32)
refresh
self.active = false
self.index = -1
end
#--------------------------------------------------------------------------
# * Refresh
#--------------------------------------------------------------------------
def refresh
self.contents.clear
@item_max = $game_party.actors.size
x = 114
y = 0
x2 = 10
self.contents.font.color = system_color
self.contents.draw_text(x2, 0, 96, 32, $data_system.words.weapon)
self.contents.draw_text(x2, 40, 96, 32, $data_system.words.armor1)
self.contents.draw_text(x2, 80, 96, 32, $data_system.words.armor2)
self.contents.draw_text(x2, 120, 96, 32, $data_system.words.armor3)
self.contents.draw_text(x2, 160, 96, 32, $data_system.words.armor4)
draw_item_name($data_weapons[$game_actors[1].weapon_id], x2 + 24, 20)
draw_item_name($data_armors[$game_actors[1].armor1_id], x2 + 24, 60)
draw_item_name($data_armors[$game_actors[1].armor2_id], x2 + 24, 100)
draw_item_name($data_armors[$game_actors[1].armor3_id], x2 + 24, 140)
draw_item_name($data_armors[$game_actors[1].armor4_id], x2 + 24, 180)
draw_actor_graphic2($game_actors[1], x + 250, y + 175)
draw_actor_name($game_actors[1], x + 75, y + 170)
draw_actor_class($game_actors[1], x + 219, y + 170)
draw_actor_level($game_actors[1], x + 75, y + 202)
draw_actor_state($game_actors[1], x + 165, y + 202)
draw_actor_exp($game_actors[1], x + 75, y + 236)
draw_actor_hp($game_actors[1], x + 311, y + 202)
draw_actor_sp($game_actors[1], x + 311, y + 236)
end
#--------------------------------------------------------------------------
# * Cursor Rectangle Update
#--------------------------------------------------------------------------
def update_cursor_rect
if @index < 0
self.cursor_rect.empty
else
self.cursor_rect.set(0, @index * 116, self.width - 32, 268)
end
end
end
#==============================================================================
# ** Window_Gold
#------------------------------------------------------------------------------
# This window displays amount of gold.
#==============================================================================
class Window_Gold < Window_Base
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize
super(0, 0, 280, 80)
self.contents = Bitmap.new(width - 32, height - 32)
refresh
end
#--------------------------------------------------------------------------
# * Refresh
#--------------------------------------------------------------------------
def refresh
self.contents.clear
cx = contents.text_size($data_system.words.gold).width
self.contents.font.color = normal_color
self.contents.draw_text(20, 10, 100, 32, "You Have", 2)
self.contents.draw_text(80, 10, 120-cx-2, 32, $game_party.gold.to_s, 2)
self.contents.font.color = system_color
self.contents.draw_text(200-cx, 10, cx, 32, $data_system.words.gold, 2)
end
end
#==============================================================================
# ** Window_PlayTime
#------------------------------------------------------------------------------
# This window displays play time on the menu screen.
#==============================================================================
class Window_PlayTime < Window_Base
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize
super(0, 0, 320, 100)
self.contents = Bitmap.new(width - 32, height - 32)
refresh
end
#--------------------------------------------------------------------------
# * Refresh
#--------------------------------------------------------------------------
def refresh
self.contents.clear
self.contents.font.color = system_color
self.contents.draw_text(4, 0, 120, 32, "Play Time")
@total_sec = Graphics.frame_count / Graphics.frame_rate
hour = @total_sec / 60 / 60
min = @total_sec / 60 % 60
sec = @total_sec % 60
text = sprintf("%02d:%02d:%02d", hour, min, sec)
self.contents.font.color = normal_color
self.contents.draw_text(4, 32, 120, 32, text, 2)
end
#--------------------------------------------------------------------------
# * Frame Update
#--------------------------------------------------------------------------
def update
super
if Graphics.frame_count / Graphics.frame_rate != @total_sec
refresh
end
end
end
#==============================================================================
# ** Window_Steps
#------------------------------------------------------------------------------
# This window displays step count on the menu screen.
#==============================================================================
class Window_Location < Window_Base
def initialize
super(0, 0, 320, 100)
self.contents = Bitmap.new (width - 32, height - 32)
refresh
end
def refresh
self.contents.clear
self.contents.font.color = system_color
self.contents.font.color = normal_color
$maps = load_data("Data/MapInfos.rxdata")
@map_id = $game_map.map_id
@currmap = $maps[@map_id].name
self.contents.draw_text(2, 30, 120, 32, @currmap)
#In the parenthesis put what you want
self.contents.draw_text(4, 0, 300, 32, "Your Current Location Is: ")
end
end
class Window_Base < Window
def draw_actor_graphic2(actor, x, y)
bitmap = RPG::Cache.battler(actor.battler_name, actor.battler_hue)
cw = bitmap.width / 1
ch = bitmap.height / 1
src_rect = Rect.new(0, 0, cw, ch)
self.contents.blt(x - cw / 2, y - ch, bitmap, src_rect)
end
end
class Scrolling_Command < Window_Base
attr_reader :index
attr_reader :help_window
SPEED = 2
HORZ_SPACING = 10
def initialize(align, side, commands, focus, startindex, disabled = [])
startup(align, side, commands, focus, disabled)
super(0, 0, @width, @height)
self.contents = Bitmap.new(@width_2, @height_2)
self.contents.font.name = $defaultfonttype
self.contents.font.size = $defaultfontsize
self.index = startindex
refresh
end
def startup(align, side, commands, focus, disabled)
@focus = (focus - 1) #to solve a graphical error this was done.
@commands = commands
@align = align
check_align # verify and convert the value of @align
set_spacing (side) #set the window sizes based on what type of menu we're using
@disabled = disabled
@com = @commands.size
@com -= 1#a graphical bug prevention step
return
end
def refresh
self.contents.clear
if @align == 0 #if using a verticle menu use the appropriate method
for i in -1...@com# again a step to prevent a graphical bug
draw_item_vert(i, normal_color)
end
elsif @align == 1 #and use the appropriate method if using a horizontal menu
for i in -1...@com #graphical bug prevention
draw_item_horz(i, normal_color)
end
end
end
def set_spacing(side)
# if verticle, make the heigth determined by the # of options, and the width by the spare side variable
if @align == 0
@height = @commands.size*32 - 32
@width = side
@height_2 = @commands.size*32 - 64
@width_2 = side - 32
#and vica versa for the horizontal menu.
elsif @align == 1
old_size = @commands[1].size # just to make it not nil
for i in @commands
if i.size >= old_size
old_size = i.size
end
end
@size = old_size * HORZ_SPACING
@height = side
@width = @commands.size*(@size) - ((@size*(3.0/2.0)).abs)
@height_2 = side - 32
@width_2 = @width - 32
horz_offset_temp=[((@size)*0.25), ((@size)*0.50), ((@size)*0.75)]
@horz_offset = horz_offset_temp.each { |x| x.abs }
end
end
#--------------------------------------------------------------------------
#-This method converts the strings to either 1 or 0 depending on the menu.
# 0 = Vertical menu
# 1 = Horizontal menu
#--------------------------------------------------------------------------
def check_align
if @align == "vert"
@align = 0
elsif @align == "horz"
@align = 1
end
#debug script
if @align == 0
# print "vert"
elsif @align == 1
# print "horz"
else #if invalid input was found in @align, set to vertical menu.
# print "error"
@align = 0
end
end
#--------------------------------------------------------------------------
#-Animation routine for the verticle menu.
#--------------------------------------------------------------------------
def anim_vert(direction)
for a in [8, 16, 24] #1/4, 1/2, and 3/4 of the destination value
click = Graphics.frame_count
self.contents.clear# clear window to keep from streaking.
for i in -1...@com #again graphic bug prevention
offset_draw_item_vert(i, normal_color, direction * a) #Draw the animation.
end
Graphics.update until Graphics.frame_count >= click + SPEED
end
refresh # draw new placement of commands
end
#--------------------------------------------------------------------------
#-Animation routine for the Horizontal menu
#-Since the routine is different for the Vert & Horz menus, Anim is not merged;
#-But will be merged in future
#--------------------------------------------------------------------------
def anim_horz(direction)
for a in @horz_offset #<<1/4, 1/2, and 3/4 of the destination value
click = Graphics.frame_count
self.contents.clear
for i in -1...@com
offset_draw_item_horz(i, normal_color, direction * a) #Draw the animation
end
Graphics.update until Graphics.frame_count >= click + SPEED
end
refresh
end
#--------------------------------------------------------------------------
#-This method draws the menu items for the Horizontal menu.
#--------------------------------------------------------------------------
def draw_item_horz(index, color)
nindex = (index - @focus + [@index, 0].max) % @commands.size
self.contents.font.color = @disabled.include?(nindex) ? disabled_color : normal_color
rect = Rect.new((@size)* index, 4, (@size), self.contents.height - 8)
self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
self.contents.draw_text(rect, @commands[nindex])
end
#--------------------------------------------------------------------------
#-This method draws the menu items for the Vertical menu
#--------------------------------------------------------------------------
def draw_item_vert(index, color)# no need to explain this method yet, willdo that later. happy.gif *is tired*
nindex = (index - @focus + [@index, 0].max) % @commands.size
self.contents.font.color = @disabled.include?(nindex) ? disabled_color : normal_color
rect = Rect.new(4, 32 * index, self.contents.width - 8, 32)
self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
self.contents.draw_text(rect, @commands[nindex])
end
#--------------------------------------------------------------------------
#This method draws the Verticle menu for the animation routine
#--------------------------------------------------------------------------
def offset_draw_item_vert(index, color, offset)
trip = offset == offset.abs ? 1 : -1
nindex = ((index + trip) - @focus + [@index, 0].max) % @commands.size
self.contents.font.color = @disabled.include?(nindex) ? disabled_color : normal_color
rect = Rect.new(4, (32 * index) + offset, self.contents.width - 8, 32)
self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
self.contents.draw_text(rect, @commands[nindex])
end
#--------------------------------------------------------------------------
#-This method draws the Horizontal menu for the animation routine
#--------------------------------------------------------------------------
def offset_draw_item_horz(index, color, offset)
trip = offset == offset.abs ? 1 : -1
nindex = ((index + trip) - @focus + [@index, 0].max) % @commands.size
self.contents.font.color = @disabled.include?(nindex) ? disabled_color : normal_color
rect = Rect.new(((@size)* index) + offset, 4, (@size), self.contents.height - 8)
self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
self.contents.draw_text(rect, @commands[nindex])
end
#--------------------------------------------------------------------------
#-Simple disable option.
#--------------------------------------------------------------------------
def disable_item(index)
@disabled.push(index)
refresh
end
#--------------------------------------------------------------------------
#-Simple enable option.
#--------------------------------------------------------------------------
def enable_item(index)
@disabled.delete(index)
refresh
end
#--------------------------------------------------------------------------
#-The index method
#--------------------------------------------------------------------------
def index=(index)
@index = index
if @index >= @commands.size
@index = 0
end
if @index < 0
@index = @commands.size - 1
end
if self.active and @help_window != nil
update_help
end
update_cursor_rect
end
#--------------------------------------------------------------------------
#-The help_window method. Used the same way as the one in Window_Selectable
#--------------------------------------------------------------------------
def help_window=(help_window)
@help_window = help_window
if self.active and @help_window != nil
update_help
end
end
#--------------------------------------------------------------------------
#-Draws the cursor in proportion to the size of the window
#--------------------------------------------------------------------------
def update_cursor_rect
if @focus < 0
self.cursor_rect.empty
return
end
if @align == 0
cursor_width = self.width - 32
y = @focus * 32 - self.oy
self.cursor_rect.set(0, y, cursor_width, 32)
elsif @align == 1
cursor_height = self.height - 32
x = (@focus * (@size) - self.ox - 6)
self.cursor_rect.set(x, 0, (@size), cursor_height)
end
end
#--------------------------------------------------------------------------
#-The update routine for the menus
#--------------------------------------------------------------------------
def update
super
if self.active and @commands.size > 0 and @index >= 0
if @align == 0
if Input.repeat?(Input::DOWN)
$game_system.se_play($data_system.cursor_se)
self.index += 1
anim_vert(-1)
end
if Input.repeat?(Input::UP)
$game_system.se_play($data_system.cursor_se)
self.index -= 1
anim_vert(1)
end
elsif @align == 1
if Input.repeat?(Input::RIGHT)
$game_system.se_play($data_system.cursor_se)
self.index += 1
anim_horz(-1)
end
if Input.repeat?(Input::LEFT)
$game_system.se_play($data_system.cursor_se)
self.index -= 1
anim_horz(1)
end
end
end
if self.active and @help_window != nil
update_help
end
update_cursor_rect
refresh
end
#end update-------------------------------------------------------
end
#end class
class Game_Actor < Game_Battler
def now_exp
return @exp - @exp_list[@level]
end
def next_exp
return @exp_list[@level+1] > 0 ? @exp_list[@level+1] - @exp_list[@level] : 0
end
end
class Window_Base < Window
alias :draw_actor_hp_original :draw_actor_hp
def draw_actor_hp(actor, x, y, width = 144)
if actor.maxhp != 0
rate = actor.hp.to_f / actor.maxhp
else
rate = 0
end
plus_x = 0
rate_x = 0
plus_y = 25
plus_width = 0
rate_width = 100
height = 10
align1 = 1
align2 = 2
align3 = 0
grade1 = 1
grade2 = 0
color1 = Color.new(0, 0, 0, 50)
color2 = Color.new(255, 255, 192, 192)
color3 = Color.new(0, 0, 0, 50)
color4 = Color.new(64, 0, 0, 50)
color5 = Color.new(216 - 24 * rate, 0 * rate, 0 * rate, 192)
color6 = Color.new(255 * rate, 215 * rate, 0 * rate, 192)
if actor.maxhp != 0
hp = (width + plus_width) * actor.hp * rate_width / 100 / actor.maxhp
else
hp = 0
end
gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
width, plus_width + width * rate_width / 100,
height, hp, align1, align2, align3,
color1, color2, color3, color4, color5, color6, grade1, grade2)
draw_actor_hp_original(actor, x, y, width)
end
alias :draw_actor_sp_original :draw_actor_sp
def draw_actor_sp(actor, x, y, width = 144)
# ��?�rate�� ��?݂�SP/MSP����
if actor.maxsp != 0
rate = actor.sp.to_f / actor.maxsp
else
rate = 1
end
plus_x = 0
rate_x = 0
plus_y = 25
plus_width = 0
rate_width = 100
height = 10
align1 = 1
align2 = 2
align3 = 0
grade1 = 1
grade2 = 0
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(255, 255, 192, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(0, 64, 0, 192)
color5 = Color.new(14 * rate, 80 - 24 * rate, 80 * rate, 192)
color6 = Color.new(62 * rate, 240 - 72 * rate, 240 * rate, 192)
if actor.maxsp != 0
sp = (width + plus_width) * actor.sp * rate_width / 100 / actor.maxsp
else
sp = (width + plus_width) * rate_width / 100
end
gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
width, plus_width + width * rate_width / 100,
height, sp, align1, align2, align3,
color1, color2, color3, color4, color5, color6, grade1, grade2)
draw_actor_sp_original(actor, x, y, width)
end
alias :draw_actor_exp_original :draw_actor_exp
def draw_actor_exp(actor, x, y, width = 204)
if actor.next_exp != 0
rate = actor.now_exp.to_f / actor.next_exp
else
rate = 1
end
plus_x = 0
rate_x = 0
plus_y = 25
plus_width = 0
rate_width = 100
height = 10
align1 = 1
align2 = 2
align3 = 0
# �O���f?[�V����?ݒ� grade1:��Q?[�W grade2:��Q?[�W
# (0:���ɃO���f?[�V���� 1:?c�ɃO���f?[�V���� 2:�߂ɃO���f?[�V����(��?d)?j
grade1 = 1
grade2 = 0
# ?F?ݒ�?Bcolor1:�O�g?Ccolor2:���g
# color3:��Q?[�W�_?[�N�J��?[?Ccolor4:��Q?[�W���C�g�J��?[
# color5:��Q?[�W�_?[�N�J��?[?Ccolor6:��Q?[�W���C�g�J��?[
color1 = Color.new(0, 0, 0, 192)
color2 = Color.new(255, 255, 192, 192)
color3 = Color.new(0, 0, 0, 192)
color4 = Color.new(64, 0, 0, 192)
color5 = Color.new(80 - 24 * rate, 80 * rate, 14 * rate, 192)
color6 = Color.new(240 - 72 * rate, 240 * rate, 62 * rate, 192)
# ��?�exp�ɕ`�悷��Q?[�W�̕?����
if actor.next_exp != 0
exp = (width + plus_width) * actor.now_exp * rate_width /
100 / actor.next_exp
else
exp = (width + plus_width) * rate_width / 100
end
# �Q?[�W�̕`��
gauge_rect(x + plus_x + width * rate_x / 100, y + plus_y,
width, plus_width + width * rate_width / 100,
height, exp, align1, align2, align3,
color1, color2, color3, color4, color5, color6, grade1, grade2)
# �I���W�i����EXP�`��?��?���?o��
draw_actor_exp_original(actor, x, y)
end
#--------------------------------------------------------------------------
# ?� �Q?[�W�̕`��
#--------------------------------------------------------------------------
def gauge_rect(x, y, rect_width, width, height, gauge, align1, align2, align3,
color1, color2, color3, color4, color5, color6, grade1, grade2)
case align1
when 1
x += (rect_width - width) / 2
when 2
x += rect_width - width
end
case align2
when 1
y -= height / 2
when 2
y -= height
end
# �g�`��
self.contents.fill_rect(x, y, width, height, color1)
self.contents.fill_rect(x + 1, y + 1, width - 2, height - 2, color2)
if align3 == 0
if grade1 == 2
grade1 = 3
end
if grade2 == 2
grade2 = 3
end
end
if (align3 == 1 and grade1 == 0) or grade1 > 0
color = color3
color3 = color4
color4 = color
end
if (align3 == 1 and grade2 == 0) or grade2 > 0
color = color5
color5 = color6
color6 = color
end
# ��Q?[�W�̕`��
self.contents.gradation_rect(x + 2, y + 2, width - 4, height - 4,
color3, color4, grade1)
if align3 == 1
x += width - gauge
end
# ��Q?[�W�̕`��
self.contents.gradation_rect(x + 2, y + 2, gauge - 4, height - 4,
color5, color6, grade2)
end
end
#------------------------------------------------------------------------------
# ?@Bitmap�N���X��?V���ȋ@�\��lj���܂�?B
#==============================================================================
class Bitmap
#--------------------------------------------------------------------------
# ?� ��`��O���f?[�V�����\��
# color1 : �X�^?[�g�J��?[
# color2 : �G���h�J��?[
# align : 0:���ɃO���f?[�V����
# 1:?c�ɃO���f?[�V����
# 2:�߂ɃO���f?[�V����?i��?d�ɂ��?��?j
#--------------------------------------------------------------------------
def gradation_rect(x, y, width, height, color1, color2, align = 0)
if align == 0
for i in x...x + width
red = color1.red + (color2.red - color1.red) * (i - x) / (width - 1)
green = color1.green +
(color2.green - color1.green) * (i - x) / (width - 1)
blue = color1.blue +
(color2.blue - color1.blue) * (i - x) / (width - 1)
alpha = color1.alpha +
(color2.alpha - color1.alpha) * (i - x) / (width - 1)
color = Color.new(red, green, blue, alpha)
fill_rect(i, y, 1, height, color)
end
elsif align == 1
for i in y...y + height
red = color1.red +
(color2.red - color1.red) * (i - y) / (height - 1)
green = color1.green +
(color2.green - color1.green) * (i - y) / (height - 1)
blue = color1.blue +
(color2.blue - color1.blue) * (i - y) / (height - 1)
alpha = color1.alpha +
(color2.alpha - color1.alpha) * (i - y) / (height - 1)
color = Color.new(red, green, blue, alpha)
fill_rect(x, i, width, 1, color)
end
elsif align == 2
for i in x...x + width
for j in y...y + height
red = color1.red + (color2.red - color1.red) *
((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
green = color1.green + (color2.green - color1.green) *
((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
blue = color1.blue + (color2.blue - color1.blue) *
((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
alpha = color1.alpha + (color2.alpha - color1.alpha) *
((i - x) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
color = Color.new(red, green, blue, alpha)
set_pixel(i, j, color)
end
end
elsif align == 3
for i in x...x + width
for j in y...y + height
red = color1.red + (color2.red - color1.red) *
((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
green = color1.green + (color2.green - color1.green) *
((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
blue = color1.blue + (color2.blue - color1.blue) *
((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
alpha = color1.alpha + (color2.alpha - color1.alpha) *
((x + width - i) / (width - 1.0) + (j - y) / (height - 1.0)) / 2
color = Color.new(red, green, blue, alpha)
set_pixel(i, j, color)
end
end
end
end
end
#==============================================================================
# ?� Sprite���W��?[��
#------------------------------------------------------------------------------
# ?@�A�j�??[�V�����̊Ǘ?��?s�����W��?[���ł�?B
#==============================================================================
module RPG
class Sprite < ::Sprite
def damage(value, critical)
dispose_damage
if value.is_a?(Numeric)
damage_string = value.abs.to_s
else
damage_string = value.to_s
end
bitmap = Bitmap.new(160, 48)
bitmap.font.name = "Arial Black"
bitmap.font.size = 32
bitmap.font.color.set(0, 0, 0)
bitmap.draw_text(-1, 12-1, 160, 36, damage_string, 1)
bitmap.draw_text(+1, 12-1, 160, 36, damage_string, 1)
bitmap.draw_text(-1, 12+1, 160, 36, damage_string, 1)
bitmap.draw_text(+1, 12+1, 160, 36, damage_string, 1)
if value.is_a?(Numeric) and value < 0
bitmap.font.color.set(176, 255, 144)
else
bitmap.font.color.set(255, 255, 255)
end
bitmap.draw_text(0, 12, 160, 36, damage_string, 1)
if critical
bitmap.font.size = 20
bitmap.font.color.set(0, 0, 0)
bitmap.draw_text(-1, -1, 160, 20, "CRITICAL", 1)
bitmap.draw_text(+1, -1, 160, 20, "CRITICAL", 1)
bitmap.draw_text(-1, +1, 160, 20, "CRITICAL", 1)
bitmap.draw_text(+1, +1, 160, 20, "CRITICAL", 1)
bitmap.font.color.set(255, 255, 255)
bitmap.draw_text(0, 0, 160, 20, "CRITICAL", 1)
end
@_damage_sprite = ::Sprite.new
@_damage_sprite.bitmap = bitmap
@_damage_sprite.ox = 80 + self.viewport.ox
@_damage_sprite.oy = 20 + self.viewport.oy
@_damage_sprite.x = self.x + self.viewport.rect.x
@_damage_sprite.y = self.y - self.oy / 2 + self.viewport.rect.y
@_damage_sprite.z = 3000
@_damage_duration = 40
end
def animation(animation, hit)
dispose_animation
@_animation = animation
return if @_animation == nil
@_animation_hit = hit
@_animation_duration = @_animation.frame_max
animation_name = @_animation.animation_name
animation_hue = @_animation.animation_hue
bitmap = RPG::Cache.animation(animation_name, animation_hue)
if @@_reference_count.include?(bitmap)
@@_reference_count[bitmap] += 1
else
@@_reference_count[bitmap] = 1
end
@_animation_sprites = []
if @_animation.position != 3 or not @@_animations.include?(animation)
for i in 0..15
sprite = ::Sprite.new
sprite.bitmap = bitmap
sprite.visible = false
@_animation_sprites.push(sprite)
end
unless @@_animations.include?(animation)
@@_animations.push(animation)
end
end
update_animation
end
def loop_animation(animation)
return if animation == @_loop_animation
dispose_loop_animation
@_loop_animation = animation
return if @_loop_animation == nil
@_loop_animation_index = 0
animation_name = @_loop_animation.animation_name
animation_hue = @_loop_animation.animation_hue
bitmap = RPG::Cache.animation(animation_name, animation_hue)
if @@_reference_count.include?(bitmap)
@@_reference_count[bitmap] += 1
else
@@_reference_count[bitmap] = 1
end
@_loop_animation_sprites = []
for i in 0..15
sprite = ::Sprite.new
sprite.bitmap = bitmap
sprite.visible = false
@_loop_animation_sprites.push(sprite)
end
update_loop_animation
end
def animation_set_sprites(sprites, cell_data, position)
for i in 0..15
sprite = sprites[i]
pattern = cell_data[i, 0]
if sprite == nil or pattern == nil or pattern == -1
sprite.visible = false if sprite != nil
next
end
sprite.visible = true
sprite.src_rect.set(pattern % 5 * 192, pattern / 5 * 192, 192, 192)
if position == 3
if self.viewport != nil
sprite.x = self.viewport.rect.width / 2
sprite.y = self.viewport.rect.height - 160
else
sprite.x = 320
sprite.y = 240
end
else
sprite.x = self.x + self.viewport.rect.x -
self.ox + self.src_rect.width / 2
sprite.y = self.y + self.viewport.rect.y -
self.oy + self.src_rect.height / 2
sprite.y -= self.src_rect.height / 4 if position == 0
sprite.y += self.src_rect.height / 4 if position == 2
end
sprite.x += cell_data[i, 1]
sprite.y += cell_data[i, 2]
sprite.z = 2000
sprite.ox = 96
sprite.oy = 96
sprite.zoom_x = cell_data[i, 3] / 100.0
sprite.zoom_y = cell_data[i, 3] / 100.0
sprite.angle = cell_data[i, 4]
sprite.mirror = (cell_data[i, 5] == 1)
sprite.opacity = cell_data[i, 6] * self.opacity / 255.0
sprite.blend_type = cell_data[i, 7]
end
end
end
end