#--------------------------------------------------------------------------
# * Begin SDK Enable Test
#--------------------------------------------------------------------------
if SDK.enabled?("L's Skill Scene")
#==============================================================================
# * Window_Skill_Header (Currently Dummy)
#==============================================================================
class Window_Skill_Header < Window_Base
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize
super(0, 0, 640, 64)
#Create Bitmap
self.contents = Bitmap.new(width - 32, height - 32)
#Refresh and add the contents to window
refresh
end
#--------------------------------------------------------------------------
# * Refresh
#--------------------------------------------------------------------------
def refresh
#Clear Bitmap
self.contents.clear
end
end
#==============================================================================
# * Window_SkillStatus
#==============================================================================
class Window_SkillStatus < Window_Base
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize(actor)
super(0, 64, 240, 352)
#Create Bitmap
self.contents = Bitmap.new(width - 32, height - 32)
#Refresh and add the contents to window
@actor = actor
refresh
end
#--------------------------------------------------------------------------
# * Refresh
#--------------------------------------------------------------------------
def refresh
#Clear Bitmap
self.contents.clear
#Draw actor's status
draw_actor_name(@actor, 16, 0)
draw_actor_level(@actor, 128, 0)
draw_actor_graphic(@actor, 96, 128)
draw_actor_class(@actor, 16, 160)
draw_actor_state(@actor, 16, 192)
draw_actor_hp(@actor, 16, 224)
draw_actor_sp(@actor, 16, 256)
end
end
#==============================================================================
# * Window_Skill
#==============================================================================
class Window_Skill < Window_Selectable
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize(actor)
if $game_temp.in_battle
super(0, 128, 640, 352)
else
super(240, 64, 400, 352)
end
#Create Bitmap
self.contents = Bitmap.new(width - 32, height - 32)
@actor = actor
if $game_temp.in_battle
@column_max = 2
else
@column_max = 1
end
#Refresh and add the contents to window
refresh
self.index = 0
# If in battle, move window to center of screen
# and make it semi-transparent
if $game_temp.in_battle
self.y = 64
self.height = 256
self.back_opacity = 160
end
end
#--------------------------------------------------------------------------
# * Acquiring Skill
#--------------------------------------------------------------------------
def skill
return @data[self.index]
end
#--------------------------------------------------------------------------
# * Refresh
#--------------------------------------------------------------------------
def refresh
if self.contents != nil
self.contents.dispose
self.contents = nil
end
@data = []
for i in 0...@actor.skills.size
skill = $data_skills[@actor.skills[i]]
if skill != nil
@data.push(skill)
end
end
# If item count is not 0, make a bit map and draw all items
@item_max = @data.size
if @item_max > 0
self.contents = Bitmap.new(width - 32, row_max * 32)
for i in 0...@item_max
draw_item(i)
end
end
end
#--------------------------------------------------------------------------
# * Draw Item
# index : item number
#--------------------------------------------------------------------------
def draw_item(index)
skill = @data[index]
if @actor.skill_can_use?(skill.id)
self.contents.font.color = normal_color
else
self.contents.font.color = disabled_color
end
x = 4 + index % 2 * (288 + 32)
y = index / 2 * 32
rect = Rect.new(x, y, self.width / @column_max - 32, 32)
self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
bitmap = RPG::Cache.icon(skill.icon_name)
opacity = self.contents.font.color == normal_color ? 255 : 128
self.contents.blt(x, y + 4, bitmap, Rect.new(0, 0, 24, 24), opacity)
self.contents.draw_text(x + 28, y, 204, 32, skill.name, 0)
if $game_temp.in_battle
self.contents.draw_text(x + 232, y, 48, 32, skill.sp_cost.to_s, 2)
else
self.contents.draw_text(x + 310, y, 48, 32, skill.sp_cost.to_s, 2)
end
end
#--------------------------------------------------------------------------
# * Help Text Update
#--------------------------------------------------------------------------
def update_help
@help_window.set_text(self.skill == nil ? "" : self.skill.description)
end
end
#==============================================================================
# ** Scene_Skill
#------------------------------------------------------------------------------
# This class performs skill screen processing.
#==============================================================================
class Scene_Skill < SDK::Scene_Base
#--------------------------------------------------------------------------
# * Object Initialization
# actor_index : actor index
#--------------------------------------------------------------------------
def initialize(actor_index = 0, equip_index = 0)
@actor_index = actor_index
super()
end
#--------------------------------------------------------------------------
# * Main Processing : Variable Initialization
#--------------------------------------------------------------------------
def main_variable
super
# Get actor
@actor = $game_party.actors[@actor_index]
end
#--------------------------------------------------------------------------
# * Main Processing : Window Initialization
#--------------------------------------------------------------------------
def main_window
super
# Make help window, status window, and skill window
@header_window = Window_Skill_Header.new
@help_window = Window_Help.new
@help_window.y = 416
@status_window = Window_SkillStatus.new(@actor)
@status_window.y = 64
@skill_window = Window_Skill.new(@actor)
@skill_window.y = 64
@skill_window.height = 352
# Associate help window
@skill_window.help_window = @help_window
# Make target window (set to invisible / inactive)
@target_window = Window_Target.new
@target_window.visible = false
@target_window.active = false
end
#--------------------------------------------------------------------------
# * Frame Update
#--------------------------------------------------------------------------
def update
super
# If skill window is active: call update_skill
if @skill_window.active
update_skill
return
# If skill target is active: call update_target
elsif @target_window.active
update_target
return
end
end
end
#--------------------------------------------------------------------------
# * End SDK Enable Test
#--------------------------------------------------------------------------
end
L's Custom Status Scene
Code:
# L's Custom Status Screen
#--------------------------------------------------------------------------
# * Begin SDK Log
#--------------------------------------------------------------------------
SDK.log("L's Custom Status Screen", 'L', 'Initial', '2009-02-27')
#--------------------------------------------------------------------------
# * Begin SDK Enable Test
#--------------------------------------------------------------------------
if SDK.enabled?("L's Custom Status Screen")
class Window_Base < Window
SYSTEM_WORD_EVA = "Evade" #
#--------------------------------------------------------------------------
# * Draw Parameter
# actor : actor
# x : draw spot x-coordinate
# y : draw spot y-coordinate
# type : parameter type (0-6)
#--------------------------------------------------------------------------
def draw_actor_parameter(actor, x, y, type)
case type
when 0
parameter_name = $data_system.words.atk
parameter_value = actor.atk
when 1
parameter_name = $data_system.words.pdef
parameter_value = actor.pdef
when 2
parameter_name = $data_system.words.mdef
parameter_value = actor.mdef
when 3
parameter_name = $data_system.words.str
parameter_value = actor.str
when 4
parameter_name = $data_system.words.dex
parameter_value = actor.dex
when 5
parameter_name = $data_system.words.agi
parameter_value = actor.agi
when 6
parameter_name = $data_system.words.int
parameter_value = actor.int
when 7 #
parameter_name = SYSTEM_WORD_EVA #
parameter_value = actor.eva #
end
self.contents.font.color = system_color
self.contents.draw_text(x, y, 120, 32, parameter_name)
self.contents.font.color = normal_color
self.contents.draw_text(x + 120, y, 36, 32, parameter_value.to_s, 2)
end
end
#==============================================================================
# * Window_Actor_NamePlate
#==============================================================================
class Window_Actor_NamePlate < Window_Base
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize(actor)
super(240, 0, 400, 64)
#Create Bitmap
self.contents = Bitmap.new(width - 32, height - 32)
@actor = actor
#Refresh and add the contents to window
refresh
end
#--------------------------------------------------------------------------
# * Refresh
#--------------------------------------------------------------------------
def refresh
#Clear Bitmap
self.contents.clear
draw_actor_name(@actor, 16, 0)
draw_actor_class(@actor, 240, 0)
end
end
#==============================================================================
# ** Scene_Status
#------------------------------------------------------------------------------
# This class performs status screen processing.
#==============================================================================
class Scene_Status < SDK::Scene_Base
#--------------------------------------------------------------------------
# * Object Initialization
# actor_index : actor index
#--------------------------------------------------------------------------
def initialize(actor_index = 0, equip_index = 0)
@actor_index = actor_index
end
#--------------------------------------------------------------------------
# * Main Processing : Variable Initialization
#--------------------------------------------------------------------------
def main_variable
super
# Get actor
@actor = $game_party.actors[@actor_index]
end
#--------------------------------------------------------------------------
# * Main Processing : Window Initialization
#--------------------------------------------------------------------------
def main_window
super
# Make status window
@window_actor_name = Window_Actor_NamePlate.new(@actor)
@window_actor_state1 = Window_Actor_Info1.new(@actor)
@window_actor_state2 = Window_Actor_Info2.new(@actor)
end
end
#--------------------------------------------------------------------------
# * End SDK Enable Test
#--------------------------------------------------------------------------
end
Instructions
These scripts require RMXP SDK 2.x. Copy and paste script under SDK, above 'main'. It's a simple 'copy & paste', but you may need some tweaking(like showing face or battler picture in Scene_Status).
FAQ
Q: Can you make them non-SDK?
A: I have no plan. But it's not hard to convert them.
Q: What is the purpose of 'Window_Skill_Header'?
A: It's just a dummy, a placeholder. You can add some text there, or remove it from the scene(you have to change height of 'Window_SkillStatus' and 'Window_Skill' if you do that)
Q: 'No Picture'? WTF?
A: You can add face picture, but since I didn't provide the 'draw_actor_face' method, you have to add the method and picture.
Compatibility
So far, this is compatible to:
- Any CMS that changes main menu only
- Grouping and Details by DerVVulfman. Although you have to edit window position to make it look right.
(compatibility with KGC_SkillGrouping is yet unconfirmed)
Credits and Thanks
Thanks to:
Mr. Mo for Window Scene Wizard
and other scripters for showing me how to make these scenes
Authoress' Notes
Since I'm away from the scene now, maybe there won't be enough support for my scripts.
#--------------------------------------------------------------------------
# * Begin SDK Requirement Check
#--------------------------------------------------------------------------
SDK.check_requirements(2.0, [1])
#--------------------------------------------------------------------------
# * Begin SDK Enable Test
#--------------------------------------------------------------------------
if SDK.enabled?("L's CMS #4")
Order = 'Order'
Party = 'Party'
Option = 'Option'
Quest = 'Quest'
System = 'System'
Menu_Commands = [Item, Skill, Equip, Status, Order, Party, System]
SysMenu_Commands = [Option, Save, Load, End_Game]
end
end
#==============================================================================
# ? Game_Map
#==============================================================================
class Game_Map
def name
$map_infos[@map_id]
end
end
#========================================
#? Scene_Title
#--------------------------------------------------------------------------------
# Setting functions for the Title
#========================================
class Scene_Title
$map_infos = load_data("Data/MapInfos.rxdata")
for key in $map_infos.keys
$map_infos[key] = $map_infos[key].name
end
end
self.contents.font.color = normal_color
self.contents.draw_text(4, 100, 200, 32, $game_map.name.to_s)
end
#--------------------------------------------------------------------------
# * Frame Update
#--------------------------------------------------------------------------
def update
super
if Graphics.frame_count / Graphics.frame_rate != @total_sec
refresh
end
end
end
#===========================================================
# This class is almost identical to command window from Cogwheel menu, except
#command check method originated from SDK 2.x.
#===========================================================
class Window_TwoColumnMenuCommand < Window_Selectable
#--------------------------------------------------------------------------
# * Public Instance Variables
#--------------------------------------------------------------------------
attr_reader :commands
#--------------------------------------------------------------------------
# * Command
#--------------------------------------------------------------------------
def command(index = self.index)
return @commands[index]
end
#--------------------------------------------------------------------------
# * Commands
#--------------------------------------------------------------------------
def commands=(commands)
# Return if Commands Are Same
return if @commands == commands
# Reset Commands
@commands = commands
# Resets Item Max
item_max = @item_max
@item_max = @commands.size
# If Item Max Changes
unless item_max == @item_max
# Deletes Existing Contents (If Exist)
unless self.contents.nil?
self.contents.dispose
self.contents = nil
end
# Recreates Contents
self.contents = Bitmap.new(width - 32, @item_max * 32)
end
# Refresh Window
refresh
end
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize(width, commands)
# Compute window height from command quantity
super(0, 0, width, ((commands.size/2) + (commands.size%2)) * 32 + 32)
@item_max = commands.size
@commands = commands
@column_max = 2
self.contents = Bitmap.new(width - 32, @item_max * 32)
refresh
self.index = 0
end
#--------------------------------------------------------------------------
# * Refresh
#--------------------------------------------------------------------------
def refresh
self.contents.clear
for i in 0...@item_max
draw_item(i, normal_color)
end
end
#--------------------------------------------------------------------------
# * Cursor Rectangle Update
#--------------------------------------------------------------------------
def update_cursor_rect
if @index < 0
self.cursor_rect.empty
else
self.cursor_rect.set((index%2)*(width/2), 32*(index/2), width/2 - 32, 32)
end
end
#--------------------------------------------------------------------------
# * Draw Item
# index : item number
# color : text color
#--------------------------------------------------------------------------
def draw_item(index, color)
self.contents.font.color = color
rect = Rect.new(4 + (index%2)*(width/2), 32 * (index/2), width/2 - 32, 32)
self.contents.fill_rect(rect, Color.new(0, 0, 0, 0))
self.contents.draw_text(rect, @commands[index])
end
#--------------------------------------------------------------------------
# * Disable Item
# index : item number
#--------------------------------------------------------------------------
def disable_item(index)
draw_item(index, disabled_color)
end
end
#==============================================================================
# Window_CompactMenuStatus
#==============================================================================
class Window_CompactMenuStatus < Window_Selectable
#--------------------------------------------------------------------------
# * Object Initialization
#--------------------------------------------------------------------------
def initialize
super(0, 320, 640, 160)
#Create Bitmap
self.contents = Bitmap.new(width - 32, height - 32)
self.contents.font.size = 20
#Refresh and add the contents to window
refresh
self.active = false
self.index = -1
end
#--------------------------------------------------------------------------
# * Refresh
#--------------------------------------------------------------------------
def refresh
#Clear Bitmap
self.contents.clear
@item_max = $game_party.actors.size
@column_max = $game_party.actors.size
for i in 0...$game_party.actors.size
x = i * 160
y = 0
actor = $game_party.actors[i]
draw_actor_graphic(actor, x + 16, y + 60)
draw_actor_class(actor, x + 48, y)
draw_actor_level(actor, x + 48, y + 24)
draw_actor_state(actor, x + 48, y + 48)
draw_actor_hp(actor, x+4, y + 72)
draw_actor_sp(actor, x+4, y + 96)
end
end
#--------------------------------------------------------------------------
# * Cursor Rectangle Update
#--------------------------------------------------------------------------
def update_cursor_rect
if @index < 0
self.cursor_rect.empty
else
self.cursor_rect.set((@index*160), 0, 128, 128)
end
end
end
#==============================================================================
# ** Scene_Menu
#------------------------------------------------------------------------------
# This class performs menu screen processing.
#==============================================================================
class Scene_Menu < SDK::Scene_Base
#--------------------------------------------------------------------------
# * Object Initialization
# menu_index : command cursor's initial position
#--------------------------------------------------------------------------
def initialize(menu_index = 0)
@menu_index = menu_index
party_order_init
end
#--------------------------------------------------------------------------
# * Main Processing : Spriteset Initialization
#--------------------------------------------------------------------------
def main_spriteset
#Draw Background
@background = Spriteset_Map.new
end
#--------------------------------------------------------------------------
# * Party Order Change Initiation
#--------------------------------------------------------------------------
def party_order_init
@changer = 0 #Change Party Order by Yargovish
@where = 0 #
@checker = 0 #
end
#--------------------------------------------------------------------------
# * Main Processing : Window Initialization
#--------------------------------------------------------------------------
def main_window
super
# Make main command window
main_command_window
system_command_window
# Make Info Window
@infos_window = Window_Infos.new
@infos_window.x = 420
@infos_window.y = 16
# Make status window
@status_window = Window_CompactMenuStatus.new
end
#--------------------------------------------------------------------------
# * Main Processing : Window Initialization : Main Command
#--------------------------------------------------------------------------
def main_command_window
# Make command window
command = SDK::Scene_Commands::Scene_Menu::Menu_Commands.dup
@command_window = Window_TwoColumnMenuCommand.new(288, command)
@command_window.index = @menu_index
@command_window.x = 16
@command_window.y = 16
if @command_window.height > 256
@command_window.height = 256
end
# 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 $game_party.actors.size <= 1 #
#Disable change party order
@command_window.disable_item(4)
end
end
#--------------------------------------------------------------------------
# * Main Processing : Window Initialization : System Command
#--------------------------------------------------------------------------
def system_command_window
# Make command window
sys_command = SDK::Scene_Commands::Scene_Menu::SysMenu_Commands.dup
@sys_command_window = Window_Command.new(128, sys_command)
@sys_command_window.visible = false
@sys_command_window.active = false
@sys_command_window.x = 120
@sys_command_window.y = 120
#@sys_command_window.z = 0
check_save_available
check_load_available
end
#-----------------
def check_save_available
# If save is forbidden
if $game_system.save_disabled
# Disable save
@sys_command_window.disable_item(1)
end
end
#-----------------
def check_load_available
#Check if saved file exists
@load_enabled = false
for i in 0..3
if (FileTest.exist?("Save#{i+1}.rxdata"))
@load_enabled = true
end
end
if !@load_enabled
#Put your @command_window.disable_item(index)
@sys_command_window.disable_item(2)
end
end
#--------------------------------------------------------------------------
# * Frame Update
#--------------------------------------------------------------------------
def update
super
# If command window is active: call update_command
if @command_window.active
update_command
return
# If status window is active: call update_status
elsif @status_window.active
update_status
return
end
if @sys_command_window.active
@sys_command_window.z = +500
end
# If system window is active: call update_sys_command
if @sys_command_window.active
update_sys_command
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)
# Return if Disabled Command
if disabled_main_command?
# Play buzzer SE
$game_system.se_play($data_system.buzzer_se)
return
end
# Command Input
main_command_input
return
end
end
#--------------------------------------------------------------------------
# * Update SysCommand Window
#--------------------------------------------------------------------------
def update_sys_command
if Input.trigger?(Input::B)
$game_system.se_play($data_system.cancel_se)
@command_window.active = true
@sys_command_window.active = false
@sys_command_window.visible = false
@sys_command_window.index = 0
@sys_command_window.z = -500
return
end
# If C button was pressed
if Input.trigger?(Input::C)
# Return if Disabled Command
if disabled_main_command?
# Play buzzer SE
$game_system.se_play($data_system.buzzer_se)
return
end
# Command Input
sys_command_input
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)
# Return if Disabled Command
if disabled_main_command?
# Play buzzer SE
$game_system.se_play($data_system.buzzer_se)
return
end
# Command Input
sub_command_input
return
end
end
#--------------------------------------------------------------------------
# * Disabled Main Command? Test
#--------------------------------------------------------------------------
def disabled_main_command?
# Gets Current Command
command = @command_window.command
sys_command = @sys_command_window.command
# Gets SDK Scene_Menu Commands
c = SDK::Scene_Commands::Scene_Menu
# If 0 Party Size
if $game_party.actors.size == 0
# If Item, Skill, Equip or Status Selected
if [c::Item, c::Skill, c::Equip, c::Status].include?(command)
return true
end
end
if $game_party.actors.size <= 1
if [c::Order].include?(command)
return true
end
end
# If Save Disabled && Command is Save
return true if $game_system.save_disabled && sys_command == c::Save
# If Load Disabled && Command is Load
return true if !@load_enabled && sys_command == c::Load
return false
end
#--------------------------------------------------------------------------
# * Main Command Input
#--------------------------------------------------------------------------
def main_command_input
# Play decision SE
$game_system.se_play($data_system.decision_se)
# Branch by command window cursor position
case @command_window.command
when SDK::Scene_Commands::Scene_Menu::Item # item
command_item
when SDK::Scene_Commands::Scene_Menu::Skill # skill
command_skill
when SDK::Scene_Commands::Scene_Menu::Equip # equipment
command_equip
when SDK::Scene_Commands::Scene_Menu::Status # status
command_status
when SDK::Scene_Commands::Scene_Menu::Order # order
command_order
when SDK::Scene_Commands::Scene_Menu::Party # party
command_party
when SDK::Scene_Commands::Scene_Menu::Option #option
command_option
when SDK::Scene_Commands::Scene_Menu::System # call system menu
$game_system.se_play($data_system.decision_se)
@sys_command_window.active = true
@sys_command_window.visible = true
@command_window.active = false
end
end
#--------------------------------------------------------------------------
# * System Command Input
#--------------------------------------------------------------------------
def sys_command_input
# Play decision SE
$game_system.se_play($data_system.decision_se)
# Branch by command window cursor position
case @sys_command_window.command
when SDK::Scene_Commands::Scene_Menu::Save #save
command_save
when SDK::Scene_Commands::Scene_Menu::Load #load
command_load
when SDK::Scene_Commands::Scene_Menu::End_Game #end game
command_endgame
when SDK::Scene_Commands::Scene_Menu::Option #option
command_option
end
end
#--------------------------------------------------------------------------
# * Disabled Sub Command? Test
#--------------------------------------------------------------------------
def disabled_sub_command?
# If Skill Selected
if @command_window.command == SDK::Scene_Commands::Scene_Menu::Skill
# If this actor's action limit is 2 or more
if $game_party.actors[@status_window.index].restriction >= 2
return true
end
end
return false
end
#--------------------------------------------------------------------------
# * Sub Command Input
#--------------------------------------------------------------------------
def sub_command_input
# Play decision SE
$game_system.se_play($data_system.decision_se)
# Branch by command window cursor position
case @command_window.command
when SDK::Scene_Commands::Scene_Menu::Skill # skill
command_skill
when SDK::Scene_Commands::Scene_Menu::Equip # equipment
command_equip
when SDK::Scene_Commands::Scene_Menu::Status # status
command_status
when SDK::Scene_Commands::Scene_Menu::Order # order
command_order
end
end
#--------------------------------------------------------------------------
# * Command : Item
#--------------------------------------------------------------------------
def command_item
# Switch to item screen
$scene = Scene_Item.new
end
#--------------------------------------------------------------------------
# * Command : Skill
#--------------------------------------------------------------------------
def command_skill
# If Main Command Active
if @command_window.active
# Activate Status Window
active_status_window
return
end
# Switch to skill screen
$scene = Scene_Skill.new(@status_window.index)
end
#--------------------------------------------------------------------------
# * Command : Equip
#--------------------------------------------------------------------------
def command_equip
# If Main Command Active
if @command_window.active
# Activate Status Window
active_status_window
return
end
# Switch to equipment screen
$scene = Scene_Equip.new(@status_window.index)
end
#--------------------------------------------------------------------------
# * Command : Status
#--------------------------------------------------------------------------
def command_status
# If Main Command Active
if @command_window.active
# Activate Status Window
active_status_window
return
end
# Switch to status screen
$scene = Scene_Status.new(@status_window.index)
end
#--------------------------------------------------------------------------
# * Command : Order
#--------------------------------------------------------------------------
def command_order
# If Main Command Active
if @command_window.active
# Activate Status Window
active_status_window
@checker = 0
return
end
#Change Party Order by Yargovish
if @checker == 0
@changer = $game_party.actors[@status_window.index]
@where = @status_window.index
@checker = 1
else
$game_party.actors[@where] = $game_party.actors[@status_window.index]
$game_party.actors[@status_window.index] = @changer
@checker = 0
@status_window.refresh
$game_player.refresh #
end
end
#--------------------------------------------------------------------------
# * Command : Party
#--------------------------------------------------------------------------
def command_party
# Switch to party change screen
#Put your Party Change Scene here
end
#--------------------------------------------------------------------------
# * Command : Option
#--------------------------------------------------------------------------
def command_option
# Switch to option screen
#Put your Option Scene here
end
#--------------------------------------------------------------------------
# * Command : Quest
#--------------------------------------------------------------------------
def command_quest
# Switch to quest screen
#Put your Quest Scene here
end
#--------------------------------------------------------------------------
# * Command : Save
#--------------------------------------------------------------------------
def command_save
# Switch to save screen
$scene = Scene_Save.new
end
#--------------------------------------------------------------------------
# * Command : Load
#--------------------------------------------------------------------------
def command_load
# Switch to load screen
$scene = Scene_Load.new
end
#--------------------------------------------------------------------------
# * Command : End Game
#--------------------------------------------------------------------------
def command_endgame
# Switch to end game screen
$scene = Scene_End.new
end
#--------------------------------------------------------------------------
# * Activate Status Window
#--------------------------------------------------------------------------
def active_status_window
# Make status window active
@command_window.active = false
@status_window.active = true
@status_window.index = 0
end
end
#--------------------------------------------------------------------------
# * End SDK Enable Test
#--------------------------------------------------------------------------
end
L's Custom Menu Scenes
![[Image: rmxpskillscenetest01nz4.png]](http://img7.imageshack.us/img7/2917/rmxpskillscenetest01nz4.png)
![[Image: rmxpstatusscenetest01.png]](http://img11.imageshack.us/img11/3525/rmxpstatusscenetest01.png)
![[Image: rmxpcms003.png]](http://img8.imageshack.us/img8/7051/rmxpcms003.png)
