07-05-2006, 01:00 PM
Tasty custom menu screen with gradients
tktarr
Jul 5 2006
This is quite a nice looking menu for you RPG Maker Xp Fans.
I DID NOT MAKE THIS SCRIPT! NO CREDIT IS DUE FOR ME!
ok here is the script for people who need it
Put this above main and name it Party_Change
then insert another above the party_change script called Window_Location and put this code in it
tktarr
Jul 5 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.
This is quite a nice looking menu for you RPG Maker Xp Fans.
I DID NOT MAKE THIS SCRIPT! NO CREDIT IS DUE FOR ME!
ok here is the script for people who need it
Put this above main and name it Party_Change
Code:
#==============================================================================
# Scene_Switch class definition
#------------------------------------------------------------------------------
# This class represents the party switching sub-screen. It allows the player
# to switch in and out characters from the party. Characters that are not in
# the party but that are available are said 'in reserve'.
#
# Characters available are those that exist in Game_Actors::data and whose
# property unavailable is set to false. In the default script, an actor is
# loaded in Game_Actors::data when s/he is added for the very first time in the
# party and is never deleted, unless it's done explicitly with scripts.
#
# This script requires you to create 2 additional attributes for the Game_Actor
# class: mandatory and unavailable. Both are boolean values.
#
# Mandatory is a boolean variable that, when set to true, means that the actor
# can't be switched out of the party. This is useful for main characters, that
# are in many RPGs required most of the time, if not always. The switch screen
# will display the word "Mandatory" in red above an actor that can't be put out
# of the party.
#
# Unavailable is another boolean variable that, when set to true, means that
# although the actor is defined in Game_Actors::data, won't appear in the
# reserve window. This is useful when a character leaves the party in the
# story, but you don't want to reset his stats and name when s/he comes back.
#
# Usage of this script requires the 3 other files: Window_SwitchParty,
# Window_SwitchReserve and Window_SwitchStatus, as well as a few modifications
# of the default scripts:
#
# 1 - In Game_Actor, add in the class definition (under "class Game_Actor
# [...]"):
# attr_reader :actor_id
# attr_accessor :mandatory
# attr_accessor :unavailable
#
# 2 - Again, in Game_Actor, add in the setup method (under "def setup"):
# mandatory = false
# unavailable = false
#
# 3 - In Game_Actors (with an "s"!) add in the class definition:
# attr_accessor :data
#
# 4 - In Game_Party, change:
# attr_reader :actors
# for
# attr_accessor :actors
#
# By exseiken, October 04, 2004
#==============================================================================
class Scene_Switch
#----------------------------------------------------------------------------
# Initialize the sub-screen. If it was called from the menu, it will return
# to the main menu when closed, otherwise, it will return to the map.
#
# Parameters:
# from_menu: Determines whether or not the scene was called from
# the menu or not [true|false]
# min_size: The minimum amount of characters that the new party
# must have [1; 4]
# max_size: The maximum amount of characters that the new party
# must have [min_size; 4]
#----------------------------------------------------------------------------
def initialize(from_menu, min_size = 1, max_size = 4)
# store the data telling whether or not the scene was called from the menu
@from_menu = from_menu
# store the array bounds for the max_size and min_size
@min_size = [[min_size, 1].max, 4].min
@max_size = [[max_size, @min_size].max, 4].min
end
#----------------------------------------------------------------------------
# The main routine, controlling the life of the object.
#----------------------------------------------------------------------------
def main
# create the window containing the current party members
@party_window = Window_SwitchParty.new
# create the window containing all available party members
@reserve_window = Window_SwitchReserve.new(10)
# create the window showing information about the selected character, be it
# from the party window or from the reserve window
@status_window = Window_SwitchStatus.new
# if the party is empty, the active window is reserve_window, otherwise
# it's the party window
if $game_party.actors.size == 0
@party_window.active = false
else
@reserve_window.active = false
end
# set this status window as the two other windows' help window
@party_window.help_window = @status_window
@reserve_window.help_window = @status_window
# display the transition
Graphics.transition
# enter the main loop
loop do
# flip the screen
Graphics.update
# get the buttons pressed
Input.update
# update the sub-screen
update
# if the scene has changed, return
if $scene != self
break
end
end
# stop drawing graphics
Graphics.freeze
# destroy the sub-windows
@status_window.dispose
@reserve_window.dispose
@party_window.dispose
end
#----------------------------------------------------------------------------
# Method called on every frame: update the contents of the scene (the 3,
# windows) and read on the keyboard.
#----------------------------------------------------------------------------
def update
# update all sub-windows
@party_window.update
@reserve_window.update
@status_window.update
# if the active screen is party_window, update it, else update the reserve
# window
if @party_window.active
update_party
return
else
update_reserve
return
end
end
#----------------------------------------------------------------------------
# Called when the focus is on the party window. Read on the keyboard and
# update the state of the scene according to the buttons pressed. If the
# played pressed B while this mode is on, the new party will be set and
# the scene will close.
#----------------------------------------------------------------------------
def update_party
# if the B (back) button was pressed, return to the preceeding screen
if Input.trigger?(Input::B)
# remove all holes in the party
new_party = @party_window.new_party.compact
# get the number of party members
n = new_party.size
# if the party doesn't have an acceptable amount of party members, don't
# allow quitting the sub-screen
if n < @min_size or n > @max_size
# play the buzzer and exit
$game_system.se_play($data_system.buzzer_se)
return
end
# play the confirm sound
$game_system.se_play($data_system.decision_se)
# set the new party
$game_party.actors = new_party
# return to the calling scene
if @from_menu
$scene = Scene_Menu.new(5)
else
$scene = Scene_Map.new
end
# refresh the player's sprite
$game_player.refresh
# skip (optimizing)
return
# if the C (confirm) button was pressed, switch the control to the reserve
# window
elsif Input.trigger?(Input::C)
# if the selected character is not nil, and is unavailable, play the buzzer
if(@party_window.actor != nil and @party_window.actor.mandatory)
# play the buzzer
$game_system.se_play($data_system.buzzer_se)
else
# play the decision sound
$game_system.se_play($data_system.decision_se)
# unactivate the party window
@party_window.active = false
# activate the reserve window
@reserve_window.active = true
end
end
end
#----------------------------------------------------------------------------
# Called when the focus is on the reserve window. Read on the keyboard and
# update the state of the scene according to the buttons pressed.
#----------------------------------------------------------------------------
def update_reserve
# if the B (back) button was pressed, give back the focus to the party
# window
if Input.trigger?(Input::B)
# play the cancel sound
$game_system.se_play($data_system.decision_se)
# unactivate the reserve window
@reserve_window.active = false
# activate the party window
@party_window.active = true
# skip
return
# if the C (confirm) button was pressed, switch the party member in reserve
# with the one selected in the party
elsif Input.trigger?(Input::C)
# play the confirm sound
$game_system.se_play($data_system.decision_se)
# swap the 2 party members
@party_window.change_selection(@reserve_window.swap_characters(@party_window.actor))
# unactivate the reserve window
@reserve_window.active = false
# activate the party window
@party_window.active = true
end
end
end
#==============================================================================
# Window_SwitchParty class definition
#------------------------------------------------------------------------------
# A window that displays all 4 character slots in the party, and offers a
# cursor to modify it.
#
# By exseiken, October 04, 2004
#==============================================================================
class Window_SwitchParty < Window_Selectable
#----------------------------------------------------------------------------
# Create public access variables
#----------------------------------------------------------------------------
attr_reader :new_party # The party shown in the window [R-O]
#----------------------------------------------------------------------------
# Window's constructor. Create the window's contents, makes a copy of the
# current party, then stocks it into member variable new_party, for later
# use.
#----------------------------------------------------------------------------
def initialize()
# create the window and its contents
super(0, 0, 256, 480)
self.contents = Bitmap.new(width - 32, height - 32)
# copy the party
@new_party = $game_party.actors.clone
# always 4 party members
@item_max = 4
# select the first character
if @new_party.size > 0
@index = @new_party.index(@new_party.first )
else
@index = 0
end
# draw the window's contents
refresh
# update the cursor rectangle
update_cursor_rect
end
#----------------------------------------------------------------------------
# Return the actor currently selected.
#----------------------------------------------------------------------------
def actor
# return the selected actor, or nil if none
@new_party[@index]
end
#----------------------------------------------------------------------------
# Update the contents of the window: clear the contents bitmap, then rebuild
# it.
#----------------------------------------------------------------------------
def refresh
# clear the contents of the bitmap
self.contents.clear
# draw each non-null party member
for i in 0..@new_party.size - 1
# get the actor
actor = @new_party[i]
# if the actor is valid, draw it on the screen
if actor != nil
# calculate the y coordinate
y = 116 * i
# draw the actor's graphic
draw_actor_graphic(actor, 24, y + 80)
# draw the actor's name
draw_actor_name(actor, 64, y + 32)
# if the actor is not available, write in red "can't select"
if actor.mandatory
self.contents.font.color = Color.new(255, 0, 0, 255)
self.contents.draw_text(0, y, 224, 32, "Mandatory", 1)
end
end
end
end
#----------------------------------------------------------------------------
# Update the position rectangle of the cursor.
#----------------------------------------------------------------------------
def update_cursor_rect
# reset the cursor rectangle
self.cursor_rect.set(0, 116 * @index, width - 32, 96)
end
#----------------------------------------------------------------------------
# Change the actor selected for another, then redraw the entire window.
#
# Parameters:
# actors: The actor that will replace the selected one
#----------------------------------------------------------------------------
def change_selection(actor)
# change the actor (can be nil to remove it)
@new_party[@index] = actor
# redraw the window
refresh
end
#----------------------------------------------------------------------------
# Update the help window. (Here, the help window is really the actor status
# window.)
#----------------------------------------------------------------------------
def update_help
# draw the selected actor's name, level, status conditions and stats
@help_window.draw_actor_status(@new_party[@index])
end
end
#==============================================================================
# Window_SwitchReserve class definition
#------------------------------------------------------------------------------
# A window that displays all characters available to pick in the party. Offers
# a cursor to select them
#
# By exseiken, October 04, 2004
#==============================================================================
class Window_SwitchReserve < Window_Selectable
#----------------------------------------------------------------------------
# Window constructor. Create the contents bitmap and fill it with all
# characters that are not into the party, but that are loaded in the data
# member of the Game_Actors global object.
#
# Parameters:
# max_size: The maximum of characters that can fit into that
# window
#----------------------------------------------------------------------------
def initialize(max_size)
# initialize the window and its contents
super(256, 128, 384, 352)
self.contents = Bitmap.new(width - 32, height - 32)
# initialize the list for the first time
@actor_list = $game_actors.data.clone
# remove currently active party members
$game_party.actors.each do |actor|
@actor_list[actor.actor_id] = nil
end
# remove all actors that are unavailable
$game_actors.data.each do |actor|
if actor != nil and actor.unavailable
@actor_list[actor.actor_id] = nil
end
end
# remove all holes in the list
@actor_list.compact!
# set the maximum of characters the list can contain
@item_max = max_size
# 2 columns, 5 rows
@column_max = 2
@row_max = 5
# select the first item
@index = 0
# default: unactive
self.active = false
# draw the window's contents
refresh
# draw the cursor rectangle
update_cursor_rect
end
#----------------------------------------------------------------------------
# Update the contents of the window: clear the contents bitmap, then rebuild
# it.
#----------------------------------------------------------------------------
def refresh
# clear the contents of the bitmap
self.contents.clear
# display all actors
for i in 0..@actor_list.size
# get the concerned actor
actor = @actor_list[i]
# if the actor is non-nil, draw it
if actor != nil
# get the coordinates
x = (i & 0x01) == 1 ? 176 : 0
y = (i >> 0x01) * 64
# draw the actor's sprite
draw_actor_graphic(actor, x + 24, y + 48)
# draw the actor's name
draw_actor_name(actor, x + 64, y + 16)
end
end
end
#----------------------------------------------------------------------------
# Update the position rectangle of the cursor.
#----------------------------------------------------------------------------
def update_cursor_rect
# if the screen is not active, don't display the cursor
if not active
self.cursor_rect.empty
# otherwise, display it
else
self.cursor_rect.set((@index & 0x01) == 1 ? 176 : 0, (@index >> 0x01) * 64, 176, 64)
end
end
#----------------------------------------------------------------------------
# Takes a character, put in into the list at the selected position, and
# returns the character that was presently there. If there was no
# character, returns nil.
#
# Parameters:
# actor_to_switch: The character to put at the selected position
#----------------------------------------------------------------------------
def swap_characters(actor_to_switch)
# store the old actor (needed for swapping)
old_actor = @actor_list[@index]
# put the new actor at the place
@actor_list[@index] = actor_to_switch
# redraw the window
refresh
# return the old actor
return old_actor
end
#----------------------------------------------------------------------------
# Update the help window. (Here, the help window is really the actor status
# window.)
#----------------------------------------------------------------------------
def update_help
# draw the selected actor's name, level, status conditions and stats
@help_window.draw_actor_status(@actor_list[@index])
end
end
#==============================================================================
# Window_SwitchStatus class definition
#------------------------------------------------------------------------------
# A window that displays the status of a character being selected.
#
# By exseiken, October 04, 2004
#==============================================================================
class Window_SwitchStatus < Window_Base
#----------------------------------------------------------------------------
# Construct the window: create the contents bitmap.
#----------------------------------------------------------------------------
def initialize
# create the window and initialize its contents
super(256, 0, 384, 128)
self.contents = Bitmap.new(width - 32, height - 32)
end
#----------------------------------------------------------------------------
# Draw the status on an actor on the window's contents.
#
# Parameters:
# actor: The actor to put on the screen
#----------------------------------------------------------------------------
def draw_actor_status(actor)
# clear the contents of the bitmap
self.contents.clear
# if the actor to draw is nil, leave the window empty
if actor == nil
return
end
# draw the actor's graphic
draw_actor_graphic(actor, 24, 56)
# draw the actor's name, level
draw_actor_name(actor, 64, 0)
draw_actor_level(actor, 288, 0)
draw_actor_hp(actor, 64, 32)
draw_actor_sp(actor, 64, 64)
end
endthen insert another above the party_change script called Window_Location and put this code in it
Code:
#==============================================================================
# ■ Window_Steps
#------------------------------------------------------------------------------
# メニュー画面で歩数を表示するウィンドウです。
#==============================================================================
class Window_Location < Window_Base
#--------------------------------------------------------------------------
# ● オブジェクト初期化
#--------------------------------------------------------------------------
def initialize
super(0, 0, 160, 96)
self.contents = Bitmap.new(width - 32, height - 32)
self.contents.font.name = $fontface
self.contents.font.size = $fontsize
refresh
end
#--------------------------------------------------------------------------
# ● リフレッシュ
#--------------------------------------------------------------------------
def refresh
self.contents.clear
self.contents.font.color = system_color
self.contents.draw_text(4, 0, 120, 32, "Location:")
self.contents.font.color = normal_color
self.contents.draw_text(4, 32, 120, 32, $game_map.name)
end
end