System de PHS

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

# 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

end

#==============================================================================
# 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 scrïpt, 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 scrïpts.
#
# This scrïpt 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 scrïpt requires the 3 other files: Window_SwitchParty,
# Window_SwitchReserve and Window_SwitchStatus, as well as a few modifications
# of the default scrïpts:
#
# 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::cool.gif
# 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::cool.gif
# 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

attr_reader :actor_id
attr_accessor :mandatory
attr_accessor :unavailable

mandatory = false
unavailable = false

attr_accessor :data

attr_accessor :actors