Summon/Custom Skills System! - Printable Version

Summon/Custom Skills System! - Printable Version

+- 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)
+------ Forum: Enhancement/Modification Scripts (https://www.save-point.org/forum-98.html)
+------ Thread: Summon/Custom Skills System! (/thread-6521.html)

Summon/Custom Skills System! - Reno-s--Joker - 10-07-2008

Summon/Custom Skills System!
Reno-s--Joker
Oct 7 2008

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.

Hey guys!

I wanted to give something back to this awesome community which has been a real lifesaver for me and my project.

I'm not sure if anyone has made this before - but I had a lot of trouble finding a summon system like this - and I still haven't managed to find one.

However, I made this really simple (simple = it functions...?) old FF style summon system.

You could modify this script and make it into a customisable command/skill system too. Just check for where I've modified the code.

DEMO
I sincerely recommend you download it. I just put the whole code there in case you get a 404 error. :D

.rar

Old_FF_Style_Summons.rar (Size: 180.85 KB / Downloads: 2)

THE WHOLE CODE

Windows

Code:
#==============================================================================

# ** Window_Skill

#------------------------------------------------------------------------------

# This window displays usable skills on the skill and battle screens.

# It has been modified so that it does not display summon skills.

#==============================================================================

class Window_Skill < Window_Selectable

#--------------------------------------------------------------------------

# * Object Initialization

# actor : actor

#--------------------------------------------------------------------------

def initialize(actor)

super(0, 128, 640, 352)

@actor = actor

@column_max = 2

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 = []

###This is the modification based on Leon Blade's system###

for i in 0...@actor.skills.size

skill = $data_skills[@actor.skills[i]]

if skill != nil and

#the number '17' in the brackets can be changed according to which

#element you have assigned as a marker for summons

#see database 'System' and 'Skills'

not $data_skills[@actor.skills[i]].element_set.include?(17)

@data.push(skill)

end

end

##End modification##

# 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)

self.contents.draw_text(x + 232, y, 48, 32, skill.sp_cost.to_s, 2)

end

#--------------------------------------------------------------------------

# * Help Text Update

#--------------------------------------------------------------------------

def update_help

@help_window.set_text(self.skill == nil ? "" : self.skill.description)

end

end

################################################################################

#==============================================================================

# ** Window_Summon

#------------------------------------------------------------------------------

# This window displays usable summons on the summon and battle screens.

# It has been modified so that it displays only the summon skills.

#==============================================================================

class Window_Summon < Window_Selectable

#--------------------------------------------------------------------------

# * Object Initialization

# actor : actor

#--------------------------------------------------------------------------

def initialize(actor)

super(0, 128, 640, 352)

@actor = actor

@column_max = 2

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 = []

###This is the modification based on Leon Blade's system###

for i in 0...@actor.skills.size

skill = $data_skills[@actor.skills[i]]

if skill != nil and

#the number '17' in the brackets can be changed according to which

#element you have assigned as a marker for summons

#see database 'System' and 'Skills'

$data_skills[@actor.skills[i]].element_set.include?(17)

@data.push(skill)

end

end

##End modification##

# 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)

self.contents.draw_text(x + 232, y, 48, 32, skill.sp_cost.to_s, 2)

end

#--------------------------------------------------------------------------

# * Help Text Update

#--------------------------------------------------------------------------

def update_help

@help_window.set_text(self.skill == nil ? "" : self.skill.description)

end

end

Scenes

Code:
#==============================================================================

# ** Scene_Skill

#------------------------------------------------------------------------------

# This class performs normal skill screen processing. Unchanged from original.

#==============================================================================

class Scene_Skill

#--------------------------------------------------------------------------

# * Object Initialization

# actor_index : actor index

#--------------------------------------------------------------------------

def initialize(actor_index = 0, equip_index = 0)

@actor_index = actor_index

end

#--------------------------------------------------------------------------

# * Main Processing

#--------------------------------------------------------------------------

def main

# Get actor

@actor = $game_party.actors[@actor_index]

# Make help window, status window, and skill window

@help_window = Window_Help.new

@status_window = Window_SkillStatus.new(@actor)

@skill_window = Window_Skill.new(@actor)

# 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

# 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

@help_window.dispose

@status_window.dispose

@skill_window.dispose

@target_window.dispose

end

#--------------------------------------------------------------------------

# * Frame Update

#--------------------------------------------------------------------------

def update

# Update windows

@help_window.update

@status_window.update

@skill_window.update

@target_window.update

# If skill window is active: call update_skill

if @skill_window.active

update_skill

return

end

# If skill target is active: call update_target

if @target_window.active

update_target

return

end

end

#--------------------------------------------------------------------------

# * Frame Update (if skill window is active)

#--------------------------------------------------------------------------

def update_skill

# If B button was pressed

if Input.trigger?(Input::B)

# Play cancel SE

$game_system.se_play($data_system.cancel_se)

# Switch to menu screen

$scene = Scene_Menu.new(1)

return

end

# If C button was pressed

if Input.trigger?(Input::C)

# Get currently selected data on the skill window

@skill = @skill_window.skill

# If unable to use

if @skill == nil or not @actor.skill_can_use?(@skill.id)

# Play buzzer SE

$game_system.se_play($data_system.buzzer_se)

return

end

# Play decision SE

$game_system.se_play($data_system.decision_se)

# If effect scope is ally

if @skill.scope >= 3

# Activate target window

@skill_window.active = false

@target_window.x = (@skill_window.index + 1) % 2 * 304

@target_window.visible = true

@target_window.active = true

# Set cursor position to effect scope (single / all)

if @skill.scope == 4 || @skill.scope == 6

@target_window.index = -1

elsif @skill.scope == 7

@target_window.index = @actor_index - 10

else

@target_window.index = 0

end

# If effect scope is other than ally

else

# If common event ID is valid

if @skill.common_event_id > 0

# Common event call reservation

$game_temp.common_event_id = @skill.common_event_id

# Play use skill SE

$game_system.se_play(@skill.menu_se)

# Use up SP

@actor.sp -= @skill.sp_cost

# Remake each window content

@status_window.refresh

@skill_window.refresh

@target_window.refresh

# Switch to map screen

$scene = Scene_Map.new

return

end

end

return

end

# If R button was pressed

if Input.trigger?(Input::R)

# Play cursor SE

$game_system.se_play($data_system.cursor_se)

# To next actor

@actor_index += 1

@actor_index %= $game_party.actors.size

# Switch to different skill screen

$scene = Scene_Skill.new(@actor_index)

return

end

# If L button was pressed

if Input.trigger?(Input::L)

# Play cursor SE

$game_system.se_play($data_system.cursor_se)

# To previous actor

@actor_index += $game_party.actors.size - 1

@actor_index %= $game_party.actors.size

# Switch to different skill screen

$scene = Scene_Skill.new(@actor_index)

return

end

end

#--------------------------------------------------------------------------

# * Frame Update (when target window is active)

#--------------------------------------------------------------------------

def update_target

# If B button was pressed

if Input.trigger?(Input::B)

# Play cancel SE

$game_system.se_play($data_system.cancel_se)

# Erase target window

@skill_window.active = true

@target_window.visible = false

@target_window.active = false

return

end

# If C button was pressed

if Input.trigger?(Input::C)

# If unable to use because SP ran out

unless @actor.skill_can_use?(@skill.id)

# Play buzzer SE

$game_system.se_play($data_system.buzzer_se)

return

end

# If target is all

if @target_window.index == -1

# Apply skill use effects to entire party

used = false

for i in $game_party.actors

used |= i.skill_effect(@actor, @skill)

end

end

# If target is user

if @target_window.index <= -2

# Apply skill use effects to target actor

target = $game_party.actors[@target_window.index + 10]

used = target.skill_effect(@actor, @skill)

end

# If single target

if @target_window.index >= 0

# Apply skill use effects to target actor

target = $game_party.actors[@target_window.index]

used = target.skill_effect(@actor, @skill)

end

# If skill was used

if used

# Play skill use SE

$game_system.se_play(@skill.menu_se)

# Use up SP

@actor.sp -= @skill.sp_cost

# Remake each window content

@status_window.refresh

@skill_window.refresh

@target_window.refresh

# If entire party is dead

if $game_party.all_dead?

# Switch to game over screen

$scene = Scene_Gameover.new

return

end

# If command event ID is valid

if @skill.common_event_id > 0

# Command event call reservation

$game_temp.common_event_id = @skill.common_event_id

# Switch to map screen

$scene = Scene_Map.new

return

end

end

# If skill wasn't used

unless used

# Play buzzer SE

$game_system.se_play($data_system.buzzer_se)

end

return

end

end

end

################################################################################

#==============================================================================

# ** Scene_Summon

#------------------------------------------------------------------------------

# This class performs summon screen processing.

#==============================================================================

class Scene_Summon

#--------------------------------------------------------------------------

# * Object Initialization

# actor_index : actor index

#--------------------------------------------------------------------------

def initialize(actor_index = 0, equip_index = 0)

@actor_index = actor_index

end

#--------------------------------------------------------------------------

# * Main Processing

#--------------------------------------------------------------------------

def main

# Get actor

@actor = $game_party.actors[@actor_index]

# Make help window, status window, and skill window

@help_window = Window_Help.new

@status_window = Window_SkillStatus.new(@actor)

@summon_window = Window_Summon.new(@actor)

# Associate help window

@summon_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

# 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

@help_window.dispose

@status_window.dispose

@summon_window.dispose

@target_window.dispose

end

#--------------------------------------------------------------------------

# * Frame Update

#--------------------------------------------------------------------------

def update

# Update windows

@help_window.update

@status_window.update

@summon_window.update

@target_window.update

# If skill window is active: call update_skill

if @summon_window.active

update_skill

return

end

# If skill target is active: call update_target

if @target_window.active

update_target

return

end

end

#--------------------------------------------------------------------------

# * Frame Update (if skill window is active)

#--------------------------------------------------------------------------

def update_skill

# If B button was pressed

if Input.trigger?(Input::B)

# Play cancel SE

$game_system.se_play($data_system.cancel_se)

# Switch to menu screen

$scene = Scene_Menu.new(1)

return

end

# If C button was pressed

if Input.trigger?(Input::C)

# Get currently selected data on the skill window

@skill = @summon_window.skill

# If unable to use

if @skill == nil or not @actor.skill_can_use?(@skill.id)

# Play buzzer SE

$game_system.se_play($data_system.buzzer_se)

return

end

# Play decision SE

$game_system.se_play($data_system.decision_se)

# If effect scope is ally

if @skill.scope >= 3

# Activate target window

@summon_window.active = false

@target_window.x = (@skill_window.index + 1) % 2 * 304

@target_window.visible = true

@target_window.active = true

# Set cursor position to effect scope (single / all)

if @skill.scope == 4 || @skill.scope == 6

@target_window.index = -1

elsif @skill.scope == 7

@target_window.index = @actor_index - 10

else

@target_window.index = 0

end

# If effect scope is other than ally

else

# If common event ID is valid

if @skill.common_event_id > 0

# Common event call reservation

$game_temp.common_event_id = @skill.common_event_id

# Play use skill SE

$game_system.se_play(@skill.menu_se)

# Use up SP

@actor.sp -= @skill.sp_cost

# Remake each window content

@status_window.refresh

@summon_window.refresh

@target_window.refresh

# Switch to map screen

$scene = Scene_Map.new

return

end

end

return

end

# If R button was pressed

if Input.trigger?(Input::R)

# Play cursor SE

$game_system.se_play($data_system.cursor_se)

# To next actor

@actor_index += 1

@actor_index %= $game_party.actors.size

# Switch to different skill screen

$scene = Scene_Summon.new(@actor_index)

return

end

# If L button was pressed

if Input.trigger?(Input::L)

# Play cursor SE

$game_system.se_play($data_system.cursor_se)

# To previous actor

@actor_index += $game_party.actors.size - 1

@actor_index %= $game_party.actors.size

# Switch to different skill screen

$scene = Scene_Summon.new(@actor_index)

return

end

end

#--------------------------------------------------------------------------

# * Frame Update (when target window is active)

#--------------------------------------------------------------------------

def update_target

# If B button was pressed

if Input.trigger?(Input::B)

# Play cancel SE

$game_system.se_play($data_system.cancel_se)

# Erase target window

@skill_window.active = true

@target_window.visible = false

@target_window.active = false

return

end

# If C button was pressed

if Input.trigger?(Input::C)

# If unable to use because SP ran out

unless @actor.skill_can_use?(@skill.id)

# Play buzzer SE

$game_system.se_play($data_system.buzzer_se)

return

end

# If target is all

if @target_window.index == -1

# Apply skill use effects to entire party

used = false

for i in $game_party.actors

used |= i.skill_effect(@actor, @skill)

end

end

# If target is user

if @target_window.index <= -2

# Apply skill use effects to target actor

target = $game_party.actors[@target_window.index + 10]

used = target.skill_effect(@actor, @skill)

end

# If single target

if @target_window.index >= 0

# Apply skill use effects to target actor

target = $game_party.actors[@target_window.index]

used = target.skill_effect(@actor, @skill)

end

# If skill was used

if used

# Play skill use SE

$game_system.se_play(@skill.menu_se)

# Use up SP

@actor.sp -= @skill.sp_cost

# Remake each window content

@status_window.refresh

@skill_window.refresh

@target_window.refresh

# If entire party is dead

if $game_party.all_dead?

# Switch to game over screen

$scene = Scene_Gameover.new

return

end

# If command event ID is valid

if @skill.common_event_id > 0

# Command event call reservation

$game_temp.common_event_id = @skill.common_event_id

# Switch to map screen

$scene = Scene_Map.new

return

end

end

# If skill wasn't used

unless used

# Play buzzer SE

$game_system.se_play($data_system.buzzer_se)

end

return

end

end

end

Code:
#==============================================================================

# ** Scene_Menu (modified to include summons)

#==============================================================================

class Scene_Menu

#--------------------------------------------------------------------------

# * Main Processing

#--------------------------------------------------------------------------

def main

# Make command window

s1 = $data_system.words.item

s2 = $data_system.words.skill

##Modified##

s3 = "Summons"

############

s4 = $data_system.words.equip

s5 = "Status"

s6 = "Save"

s7 = "End Game"

@command_window = Window_Command2.new(160, [s1, s2, s3, s4, s5, s6, s7])

@command_window.index = @menu_index

# If number of party members is 0

if $game_party.actors.size == 0

# Disable party-relevant menu options

@command_window.disable_item(0)

@command_window.disable_item(1)

@command_window.disable_item(2)

@command_window.disable_item(3)

@command_window.disable_item(4)

@command_window.disable_item(5)

end

# If save is forbidden

if $game_system.save_disabled

# Disable save

@command_window.disable_item(5)

end

# Make play time window

@playtime_window = Window_PlayTime.new

@playtime_window.x = 0

@playtime_window.y = 224

# Make steps window

@steps_window = Window_Steps.new

@steps_window.x = 0

@steps_window.y = 320

# Make gold window

@gold_window = Window_Gold.new

@gold_window.x = 0

@gold_window.y = 416

# Make status window

@status_window = Window_MenuStatus.new

@status_window.x = 160

@status_window.y = 0

# 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 (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

##Modified##

when 2 # summons selected

$game_system.se_play($data_system.decision_se)

@command_window.active = false

@status_window.active = true

@status_window.index = 0

############

when 3 # 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 4 # Status selected

$game_system.se_play($data_system.decision_se)

@command_window.active = false

@status_window.active = true

@status_window.index = 0

when 5 # 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 6 # 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)

##Modified##

when 2 # summons selected

$game_system.se_play($data_system.decision_se)

$scene = Scene_Summon.new(@status_window.index)

############

when 3 # equipment

# Play decision SE

$game_system.se_play($data_system.decision_se)

# Switch to equipment screen

$scene = Scene_Equip.new(@status_window.index)

when 4 # 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

El Conducter's Scrolling Window

Code:
#==============================================================================

# Section II: Dependancy WIndows - taken from El Conducter's Monster Album 4.0

#==============================================================================

#==============================================================================

# ** Window_Command2

#------------------------------------------------------------------------------

# This version of command window is a set size with scrolling commands.

#==============================================================================

class Window_Command2 < Window_Selectable

#--------------------------------------------------------------------------

# * Object Initialization

# width : window width

# commands : command text string array

#--------------------------------------------------------------------------

def initialize(width, commands)

super(0, 0, width, 224)

@item_max = commands.size

@commands = commands

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

#--------------------------------------------------------------------------

# * Draw Item

# index : item number

# color : text color

#--------------------------------------------------------------------------

def draw_item(index, color)

self.contents.font.color = 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[index])

end

#--------------------------------------------------------------------------

# * Disable Item

# index : item number

#--------------------------------------------------------------------------

def disable_item(index)

draw_item(index, disabled_color)

end

end

#==============================================================================

# ** Window_Command3

#------------------------------------------------------------------------------

# Modified of above for battle window.

#==============================================================================

class Window_Command3 < Window_Selectable

#--------------------------------------------------------------------------

# * Object Initialization

# width : window width

# commands : command text string array

#--------------------------------------------------------------------------

def initialize(width, commands)

super(0, 0, width, 160)

@item_max = commands.size

@commands = commands

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

#--------------------------------------------------------------------------

# * Draw Item

# index : item number

# color : text color

#--------------------------------------------------------------------------

def draw_item(index, color)

self.contents.font.color = 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[index])

end

#--------------------------------------------------------------------------

# * Disable Item

# index : item number

#--------------------------------------------------------------------------

def disable_item(index)

draw_item(index, disabled_color)

end

end

Scene_Battle 1

Code:
#==============================================================================

# ** Scene_Battle (part 1)

#------------------------------------------------------------------------------

# This class performs battle screen processing. Modified to include summon

# command.

#==============================================================================

class Scene_Battle

#--------------------------------------------------------------------------

# * Main Processing

#--------------------------------------------------------------------------

def main

# Initialize each kind of temporary battle data

$game_temp.in_battle = true

$game_temp.battle_turn = 0

$game_temp.battle_event_flags.clear

$game_temp.battle_abort = false

$game_temp.battle_main_phase = false

$game_temp.battleback_name = $game_map.battleback_name

$game_temp.forcing_battler = nil

# Initialize battle event interpreter

$game_system.battle_interpreter.setup(nil, 0)

# Prepare troop

@troop_id = $game_temp.battle_troop_id

$game_troop.setup(@troop_id)

# Make actor command window

s1 = $data_system.words.attack

s2 = $data_system.words.skill

##Modified##

s3 = "Summon"

############

s4 = $data_system.words.guard

s5 = $data_system.words.item

@actor_command_window = Window_Command3.new(160, [s1, s2, s3, s4, s5])

@actor_command_window.y = 160

@actor_command_window.back_opacity = 160

@actor_command_window.active = false

@actor_command_window.visible = false

# Make other windows

@party_command_window = Window_PartyCommand.new

@help_window = Window_Help.new

@help_window.back_opacity = 160

@help_window.visible = false

@status_window = Window_BattleStatus.new

@message_window = Window_Message.new

# Make sprite set

@spriteset = Spriteset_Battle.new

# Initialize wait count

@wait_count = 0

# Execute transition

if $data_system.battle_transition == ""

Graphics.transition(20)

else

Graphics.transition(40, "Graphics/Transitions/" +

$data_system.battle_transition)

end

# Start pre-battle phase

start_phase1

# 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

# Refresh map

$game_map.refresh

# Prepare for transition

Graphics.freeze

# Dispose of windows

@actor_command_window.dispose

@party_command_window.dispose

@help_window.dispose

@status_window.dispose

@message_window.dispose

if @skill_window != nil

@skill_window.dispose

end

if @summon_window != nil

@skill_window.dispose

end

if @item_window != nil

@item_window.dispose

end

if @result_window != nil

@result_window.dispose

end

# Dispose of sprite set

@spriteset.dispose

# If switching to title screen

if $scene.is_a?(Scene_Title)

# Fade out screen

Graphics.transition

Graphics.freeze

end

# If switching from battle test to any screen other than game over screen

if $BTEST and not $scene.is_a?(Scene_Gameover)

$scene = nil

end

end

#--------------------------------------------------------------------------

# * Determine Battle Win/Loss Results

#--------------------------------------------------------------------------

def judge

# If all dead determinant is true, or number of members in party is 0

if $game_party.all_dead? or $game_party.actors.size == 0

# If possible to lose

if $game_temp.battle_can_lose

# Return to BGM before battle starts

$game_system.bgm_play($game_temp.map_bgm)

# Battle ends

battle_end(2)

# Return true

return true

end

# Set game over flag

$game_temp.gameover = true

# Return true

return true

end

# Return false if even 1 enemy exists

for enemy in $game_troop.enemies

if enemy.exist?

return false

end

end

# Start after battle phase (win)

start_phase5

# Return true

return true

end

#--------------------------------------------------------------------------

# * Battle Ends

# result : results (0:win 1:lose 2:escape)

#--------------------------------------------------------------------------

def battle_end(result)

# Clear in battle flag

$game_temp.in_battle = false

# Clear entire party actions flag

$game_party.clear_actions

# Remove battle states

for actor in $game_party.actors

actor.remove_states_battle

end

# Clear enemies

$game_troop.enemies.clear

# Call battle callback

if $game_temp.battle_proc != nil

$game_temp.battle_proc.call(result)

$game_temp.battle_proc = nil

end

# Switch to map screen

$scene = Scene_Map.new

end

#--------------------------------------------------------------------------

# * Battle Event Setup

#--------------------------------------------------------------------------

def setup_battle_event

# If battle event is running

if $game_system.battle_interpreter.running?

return

end

# Search for all battle event pages

for index in 0...$data_troops[@troop_id].pages.size

# Get event pages

page = $data_troops[@troop_id].pages[index]

# Make event conditions possible for reference with c

c = page.condition

# Go to next page if no conditions are appointed

unless c.turn_valid or c.enemy_valid or

c.actor_valid or c.switch_valid

next

end

# Go to next page if action has been completed

if $game_temp.battle_event_flags[index]

next

end

# Confirm turn conditions

if c.turn_valid

n = $game_temp.battle_turn

a = c.turn_a

b = c.turn_b

if (b == 0 and n != a) or

(b > 0 and (n < 1 or n < a or n % b != a % b))

next

end

end

# Confirm enemy conditions

if c.enemy_valid

enemy = $game_troop.enemies[c.enemy_index]

if enemy == nil or enemy.hp * 100.0 / enemy.maxhp > c.enemy_hp

next

end

end

# Confirm actor conditions

if c.actor_valid

actor = $game_actors[c.actor_id]

if actor == nil or actor.hp * 100.0 / actor.maxhp > c.actor_hp

next

end

end

# Confirm switch conditions

if c.switch_valid

if $game_switches[c.switch_id] == false

next

end

end

# Set up event

$game_system.battle_interpreter.setup(page.list, 0)

# If this page span is [battle] or [turn]

if page.span <= 1

# Set action completed flag

$game_temp.battle_event_flags[index] = true

end

return

end

end

#--------------------------------------------------------------------------

# * Frame Update

#--------------------------------------------------------------------------

def update

# If battle event is running

if $game_system.battle_interpreter.running?

# Update interpreter

$game_system.battle_interpreter.update

# If a battler which is forcing actions doesn't exist

if $game_temp.forcing_battler == nil

# If battle event has finished running

unless $game_system.battle_interpreter.running?

# Rerun battle event set up if battle continues

unless judge

setup_battle_event

end

end

# If not after battle phase

if @phase != 5

# Refresh status window

@status_window.refresh

end

end

end

# Update system (timer) and screen

$game_system.update

$game_screen.update

# If timer has reached 0

if $game_system.timer_working and $game_system.timer == 0

# Abort battle

$game_temp.battle_abort = true

end

# Update windows

@help_window.update

@party_command_window.update

@actor_command_window.update

@status_window.update

@message_window.update

# Update sprite set

@spriteset.update

# If transition is processing

if $game_temp.transition_processing

# Clear transition processing flag

$game_temp.transition_processing = false

# Execute transition

if $game_temp.transition_name == ""

Graphics.transition(20)

else

Graphics.transition(40, "Graphics/Transitions/" +

$game_temp.transition_name)

end

end

# If message window is showing

if $game_temp.message_window_showing

return

end

# If effect is showing

if @spriteset.effect?

return

end

# If game over

if $game_temp.gameover

# Switch to game over screen

$scene = Scene_Gameover.new

return

end

# If returning to title screen

if $game_temp.to_title

# Switch to title screen

$scene = Scene_Title.new

return

end

# If battle is aborted

if $game_temp.battle_abort

# Return to BGM used before battle started

$game_system.bgm_play($game_temp.map_bgm)

# Battle ends

battle_end(1)

return

end

# If waiting

if @wait_count > 0

# Decrease wait count

@wait_count -= 1

return

end

# If battler forcing an action doesn't exist,

# and battle event is running

if $game_temp.forcing_battler == nil and

$game_system.battle_interpreter.running?

return

end

# Branch according to phase

case @phase

when 1 # pre-battle phase

update_phase1

when 2 # party command phase

update_phase2

when 3 # actor command phase

update_phase3

when 4 # main phase

update_phase4

when 5 # after battle phase

update_phase5

end

end

end

Scene_Battle 2

Code:
#==============================================================================

# ** Scene_Battle (part 3)

#------------------------------------------------------------------------------

# This class performs battle screen processing. Modified to accomodate summons.

#==============================================================================

class Scene_Battle

#--------------------------------------------------------------------------

# * Start Actor Command Phase

#--------------------------------------------------------------------------

def start_phase3

# Shift to phase 3

@phase = 3

# Set actor as unselectable

@actor_index = -1

@active_battler = nil

# Go to command input for next actor

phase3_next_actor

end

#--------------------------------------------------------------------------

# * Go to Command Input for Next Actor

#--------------------------------------------------------------------------

def phase3_next_actor

# Loop

begin

# Actor blink effect OFF

if @active_battler != nil

@active_battler.blink = false

end

# If last actor

if @actor_index == $game_party.actors.size-1

# Start main phase

start_phase4

return

end

# Advance actor index

@actor_index += 1

@active_battler = $game_party.actors[@actor_index]

@active_battler.blink = true

# Once more if actor refuses command input

end until @active_battler.inputable?

# Set up actor command window

phase3_setup_command_window

end

#--------------------------------------------------------------------------

# * Go to Command Input of Previous Actor

#--------------------------------------------------------------------------

def phase3_prior_actor

# Loop

begin

# Actor blink effect OFF

if @active_battler != nil

@active_battler.blink = false

end

# If first actor

if @actor_index == 0

# Start party command phase

start_phase2

return

end

# Return to actor index

@actor_index -= 1

@active_battler = $game_party.actors[@actor_index]

@active_battler.blink = true

# Once more if actor refuses command input

end until @active_battler.inputable?

# Set up actor command window

phase3_setup_command_window

end

#--------------------------------------------------------------------------

# * Actor Command Window Setup

#--------------------------------------------------------------------------

def phase3_setup_command_window

# Disable party command window

@party_command_window.active = false

@party_command_window.visible = false

# Enable actor command window

@actor_command_window.active = true

@actor_command_window.visible = true

# Set actor command window position

@actor_command_window.x = @actor_index * 160

# Set index to 0

@actor_command_window.index = 0

end

#--------------------------------------------------------------------------

# * Frame Update (actor command phase)

#--------------------------------------------------------------------------

def update_phase3

# If enemy arrow is enabled

if @enemy_arrow != nil

update_phase3_enemy_select

# If actor arrow is enabled

elsif @actor_arrow != nil

update_phase3_actor_select

# If skill window is enabled

elsif @skill_window != nil

update_phase3_skill_select

# If summon window is enabled

elsif @summon_window != nil

update_phase3_summon_select

# If item window is enabled

elsif @item_window != nil

update_phase3_item_select

# If actor command window is enabled

elsif @actor_command_window.active

update_phase3_basic_command

end

end

#--------------------------------------------------------------------------

# * Frame Update (actor command phase : basic command)

#--------------------------------------------------------------------------

def update_phase3_basic_command

# If B button was pressed

if Input.trigger?(Input::B)

# Play cancel SE

$game_system.se_play($data_system.cancel_se)

# Go to command input for previous actor

phase3_prior_actor

return

end

# If C button was pressed

if Input.trigger?(Input::C)

# Branch by actor command window cursor position

case @actor_command_window.index

when 0 # attack

# Play decision SE

$game_system.se_play($data_system.decision_se)

# Set action

@active_battler.current_action.kind = 0

@active_battler.current_action.basic = 0

# Start enemy selection

start_enemy_select

when 1 # skill

# Play decision SE

$game_system.se_play($data_system.decision_se)

# Set action

@active_battler.current_action.kind = 1

# Start skill selection

start_skill_select

when 2 # summon

# Play decision SE

$game_system.se_play($data_system.decision_se)

# Set action

@active_battler.current_action.kind = 1

# Start skill selection

start_summon_select

when 3 # guard

# Play decision SE

$game_system.se_play($data_system.decision_se)

# Set action

@active_battler.current_action.kind = 0

@active_battler.current_action.basic = 1

# Go to command input for next actor

phase3_next_actor

when 4 # item

# Play decision SE

$game_system.se_play($data_system.decision_se)

# Set action

@active_battler.current_action.kind = 2

# Start item selection

start_item_select

end

return

end

end

#--------------------------------------------------------------------------

# * Frame Update (actor command phase : skill selection)

#--------------------------------------------------------------------------

def update_phase3_skill_select

# Make skill window visible

@skill_window.visible = true

# Update skill window

@skill_window.update

# If B button was pressed

if Input.trigger?(Input::B)

# Play cancel SE

$game_system.se_play($data_system.cancel_se)

# End skill selection

end_skill_select

return

end

# If C button was pressed

if Input.trigger?(Input::C)

# Get currently selected data on the skill window

@skill = @skill_window.skill

# If it can't be used

if @skill == nil or not @active_battler.skill_can_use?(@skill.id)

# Play buzzer SE

$game_system.se_play($data_system.buzzer_se)

return

end

# Play decision SE

$game_system.se_play($data_system.decision_se)

# Set action

@active_battler.current_action.skill_id = @skill.id

# Make skill window invisible

@skill_window.visible = false

# If effect scope is single enemy

if @skill.scope == 1

# Start enemy selection

start_enemy_select

# If effect scope is single ally

elsif @skill.scope == 3 or @skill.scope == 5

# Start actor selection

start_actor_select

# If effect scope is not single

else

# End skill selection

end_skill_select

# Go to command input for next actor

phase3_next_actor

end

return

end

end

###########################################################################

#--------------------------------------------------------------------------

# * Frame Update (actor command phase : summon selection)

#--------------------------------------------------------------------------

def update_phase3_summon_select

# Make skill window visible

@summon_window.visible = true

# Update skill window

@summon_window.update

# If B button was pressed

if Input.trigger?(Input::B)

# Play cancel SE

$game_system.se_play($data_system.cancel_se)

# End skill selection

end_summon_select

return

end

# If C button was pressed

if Input.trigger?(Input::C)

# Get currently selected data on the skill window

@skill = @summon_window.skill

# If it can't be used

if @skill == nil or not @active_battler.skill_can_use?(@skill.id)

# Play buzzer SE

$game_system.se_play($data_system.buzzer_se)

return

end

# Play decision SE

$game_system.se_play($data_system.decision_se)

# Set action

@active_battler.current_action.skill_id = @skill.id

# Make skill window invisible

@summon_window.visible = false

# If effect scope is single enemy

if @skill.scope == 1

# Start enemy selection

start_enemy_select

# If effect scope is single ally

elsif @skill.scope == 3 or @skill.scope == 5

# Start actor selection

start_actor_select

# If effect scope is not single

else

# End skill selection

end_summon_select

# Go to command input for next actor

phase3_next_actor

end

return

end

end

###########################################################################

#--------------------------------------------------------------------------

# * Frame Update (actor command phase : item selection)

#--------------------------------------------------------------------------

def update_phase3_item_select

# Make item window visible

@item_window.visible = true

# Update item window

@item_window.update

# If B button was pressed

if Input.trigger?(Input::B)

# Play cancel SE

$game_system.se_play($data_system.cancel_se)

# End item selection

end_item_select

return

end

# If C button was pressed

if Input.trigger?(Input::C)

# Get currently selected data on the item window

@item = @item_window.item

# If it can't be used

unless $game_party.item_can_use?(@item.id)

# Play buzzer SE

$game_system.se_play($data_system.buzzer_se)

return

end

# Play decision SE

$game_system.se_play($data_system.decision_se)

# Set action

@active_battler.current_action.item_id = @item.id

# Make item window invisible

@item_window.visible = false

# If effect scope is single enemy

if @item.scope == 1

# Start enemy selection

start_enemy_select

# If effect scope is single ally

elsif @item.scope == 3 or @item.scope == 5

# Start actor selection

start_actor_select

# If effect scope is not single

else

# End item selection

end_item_select

# Go to command input for next actor

phase3_next_actor

end

return

end

end

#--------------------------------------------------------------------------

# * Frame Update (actor command phase : enemy selection)

#--------------------------------------------------------------------------

def update_phase3_enemy_select

# Update enemy arrow

@enemy_arrow.update

# If B button was pressed

if Input.trigger?(Input::B)

# Play cancel SE

$game_system.se_play($data_system.cancel_se)

# End enemy selection

end_enemy_select

return

end

# If C button was pressed

if Input.trigger?(Input::C)

# Play decision SE

$game_system.se_play($data_system.decision_se)

# Set action

@active_battler.current_action.target_index = @enemy_arrow.index

# End enemy selection

end_enemy_select

# If skill window is showing

if @skill_window != nil

# End skill selection

end_skill_select

end

# If item window is showing

if @item_window != nil

# End item selection

end_item_select

end

# Go to command input for next actor

phase3_next_actor

end

end

#--------------------------------------------------------------------------

# * Frame Update (actor command phase : actor selection)

#--------------------------------------------------------------------------

def update_phase3_actor_select

# Update actor arrow

@actor_arrow.update

# If B button was pressed

if Input.trigger?(Input::B)

# Play cancel SE

$game_system.se_play($data_system.cancel_se)

# End actor selection

end_actor_select

return

end

# If C button was pressed

if Input.trigger?(Input::C)

# Play decision SE

$game_system.se_play($data_system.decision_se)

# Set action

@active_battler.current_action.target_index = @actor_arrow.index

# End actor selection

end_actor_select

# If skill window is showing

if @skill_window != nil

# End skill selection

end_skill_select

end

# If item window is showing

if @item_window != nil

# End item selection

end_item_select

end

# Go to command input for next actor

phase3_next_actor

end

end

#--------------------------------------------------------------------------

# * Start Enemy Selection

#--------------------------------------------------------------------------

def start_enemy_select

# Make enemy arrow

@enemy_arrow = Arrow_Enemy.new(@spriteset.viewport1)

# Associate help window

@enemy_arrow.help_window = @help_window

# Disable actor command window

@actor_command_window.active = false

@actor_command_window.visible = false

end

#--------------------------------------------------------------------------

# * End Enemy Selection

#--------------------------------------------------------------------------

def end_enemy_select

# Dispose of enemy arrow

@enemy_arrow.dispose

@enemy_arrow = nil

# If command is [fight]

if @actor_command_window.index == 0

# Enable actor command window

@actor_command_window.active = true

@actor_command_window.visible = true

# Hide help window

@help_window.visible = false

end

end

#--------------------------------------------------------------------------

# * Start Actor Selection

#--------------------------------------------------------------------------

def start_actor_select

# Make actor arrow

@actor_arrow = Arrow_Actor.new(@spriteset.viewport2)

@actor_arrow.index = @actor_index

# Associate help window

@actor_arrow.help_window = @help_window

# Disable actor command window

@actor_command_window.active = false

@actor_command_window.visible = false

end

#--------------------------------------------------------------------------

# * End Actor Selection

#--------------------------------------------------------------------------

def end_actor_select

# Dispose of actor arrow

@actor_arrow.dispose

@actor_arrow = nil

end

#--------------------------------------------------------------------------

# * Start Skill Selection

#--------------------------------------------------------------------------

def start_skill_select

# Make skill window

@skill_window = Window_Skill.new(@active_battler)

# Associate help window

@skill_window.help_window = @help_window

# Disable actor command window

@actor_command_window.active = false

@actor_command_window.visible = false

end

#--------------------------------------------------------------------------

# * End Skill Selection

#--------------------------------------------------------------------------

def end_skill_select

# Dispose of skill window

@skill_window.dispose

@skill_window = nil

# Hide help window

@help_window.visible = false

# Enable actor command window

@actor_command_window.active = true

@actor_command_window.visible = true

end

###########################################################################

#--------------------------------------------------------------------------

# * Start Summon Selection

#--------------------------------------------------------------------------

def start_summon_select

# Make skill window

@summon_window = Window_Summon.new(@active_battler)

# Associate help window

@summon_window.help_window = @help_window

# Disable actor command window

@actor_command_window.active = false

@actor_command_window.visible = false

end

#--------------------------------------------------------------------------

# * End Summon Selection

#--------------------------------------------------------------------------

def end_summon_select

# Dispose of skill window

@summon_window.dispose

@summon_window = nil

# Hide help window

@help_window.visible = false

# Enable actor command window

@actor_command_window.active = true

@actor_command_window.visible = true

end

###########################################################################

#--------------------------------------------------------------------------

# * Start Item Selection

#--------------------------------------------------------------------------

def start_item_select

# Make item window

@item_window = Window_Item.new

# Associate help window

@item_window.help_window = @help_window

# Disable actor command window

@actor_command_window.active = false

@actor_command_window.visible = false

end

#--------------------------------------------------------------------------

# * End Item Selection

#--------------------------------------------------------------------------

def end_item_select

# Dispose of item window

@item_window.dispose

@item_window = nil

# Hide help window

@help_window.visible = false

# Enable actor command window

@actor_command_window.active = true

@actor_command_window.visible = true

end

end

CREDIT

HUUUUGE thanks to Leon Blade who gave me the idea and the means to do this. Check out Leon Blade's awesome KH Menu Script.
http://www.creationasylum.net/index.php?showtopic=18684 ( CUSTOM COMPONENTS - MONSTER ALBUM 4.0)

MASSIVE thanks to El Conducter as well, who made a really useful scrolling window which I took from his Monster Album.
http://www.creationasylum.net/index.php?showtopic=14264 (MENU TITLE SCREEN SCRIPT - KINGDOM HEARTS)

I don't want to take much credit for this, as it was really a matter of substitution and copying and pasting on my part. But I still hope you can enjoy it.

~Reno-s--Joker