J'offre mon aide pour vos questions de scripts

#==============================================================================
# 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 she 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 Game_Actor < Game_Battler
                           
  attr_reader :actor_id
  attr_accessor :mandatory
  attr_accessor :unavailable
                           
  alias exseiken_setup setup
  def setup(actor_id)
    mandatory = false
    unavailable = false
    exseiken_setup(actor_id)
  end
end

class Game_Actors
  attr_accessor :data
end
                         
class Game_Party
  attr_accessor :actors
end


class Scene_Switch
         
#----------------------------------------------------------------------------
# Initialize the sub-screen. If it was called from the menu, it will return
# to the main menu when closed, otherwise, it will return to the map.
#
# Parameters:
# from_menu: Determines whether or not the scene was called from
# the menu or not [true|false]
# min_size: The minimum amount of characters that the new party
# must have [1; 4]
# max_size: The maximum amount of characters that the new party
# must have [min_size; 4]
#----------------------------------------------------------------------------
  def initialize(from_menu, min_size = 1, max_size = 4)
    # store the data telling whether or not the scene was called from the menu
    @from_menu = from_menu
    # store the array bounds for the max_size and min_size
    @min_size = [[min_size, 1].max, 4].min
    @max_size = [[max_size, @min_size].max, 4].min
  end
     
  #----------------------------------------------------------------------------
  # The main routine, controlling the life of the object.
  #----------------------------------------------------------------------------
  def main
    # create the window containing the current party members
    @party_window = Window_SwitchParty.new
    # create the window containing all available party members
    @reserve_window = Window_SwitchReserve.new(10)
    # create the window showing information about the selected character, be it
    # from the party window or from the reserve window
    @status_window = Window_SwitchStatus.new
    # if the party is empty, the active window is reserve_window, otherwise
    # it's the party window
    if $game_party.actors.size == 0
      @party_window.active = false
    else
      @reserve_window.active = false
    end
    # set this status window as the two other windows' help window
    @party_window.help_window = @status_window
    @reserve_window.help_window = @status_window
    # display the transition
    Graphics.transition
    # enter the main loop
    loop do
      # flip the screen
      Graphics.update
      # get the buttons pressed
      Input.update
      # update the sub-screen
      update
      # if the scene has changed, return
      if $scene != self
        break
      end
    end
    # stop drawing graphics
    Graphics.freeze
    # destroy the sub-windows
    @status_window.dispose
    @reserve_window.dispose
    @party_window.dispose
         
  end
         
  #----------------------------------------------------------------------------
  # Method called on every frame: update the contents of the scene (the 3,
  # windows) and read on the keyboard.
  #----------------------------------------------------------------------------
  def update
    # update all sub-windows
    @party_window.update
    @reserve_window.update
    @status_window.update
    # if the active screen is party_window, update it, else update the reserve
    # window
    if @party_window.active
      update_party
      return
    else
      update_reserve
      return
    end
  end
           
  #----------------------------------------------------------------------------
  # Called when the focus is on the party window. Read on the keyboard and
  # update the state of the scene according to the buttons pressed. If the
  # played pressed B while this mode is on, the new party will be set and
  # the scene will close.
  #----------------------------------------------------------------------------
  def update_party
    # if the B (back) button was pressed, return to the preceeding screen
    if Input.trigger?(Input::B)
      # remove all holes in the party
      new_party = @party_window.new_party.compact
      # get the number of party members
      n = new_party.size
      # if the party doesn't have an acceptable amount of party members, don't
      # allow quitting the sub-screen
      if n < @min_size or n > @max_size
        # play the buzzer and exit
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # play the confirm sound
      $game_system.se_play($data_system.decision_se)
      # set the new party
      $game_party.actors = new_party
      # return to the calling scene
      if @from_menu
        $scene = Scene_Menu.new(5)
      else
        $scene = Scene_Map.new
      end
      # refresh the player's sprite
      $game_player.refresh
      # skip (optimizing)
      return
    # if the C (confirm) button was pressed, switch the control to the reserve
    # window
    elsif Input.trigger?(Input::C)
      # if the selected character is not nil, and is unavailable, play the buzzer
      if(@party_window.actor != nil and @party_window.actor.mandatory)
        # play the buzzer
        $game_system.se_play($data_system.buzzer_se)
      else
        #play the decision sound
        $game_system.se_play($data_system.decision_se)
        # unactivate the party window
        @party_window.active = false
        # activate the reserve window
        @reserve_window.active = true
      end
                       
    end
                     
  end
                   
  #----------------------------------------------------------------------------
  # Called when the focus is on the reserve window. Read on the keyboard and
  # update the state of the scene according to the buttons pressed.
  #----------------------------------------------------------------------------
  def update_reserve
    # if the B (back) button was pressed, give back the focus to the party
    # window
    if Input.trigger?(Input::B)
      # play the cancel sound
      $game_system.se_play($data_system.decision_se)
      # unactivate the reserve window
      @reserve_window.active = false
      # activate the party window
      @party_window.active = true
      # skip
      return
    # if the C (confirm) button was pressed, switch the party member in reserve
    # with the one selected in the party
    elsif Input.trigger?(Input::C)
      # play the confirm sound
      $game_system.se_play($data_system.decision_se)
      # swap the 2 party members
      @party_window.change_selection(@reserve_window.swap_characters(@party_window.actor))
      # unactivate the reserve window
      @reserve_window.active = false
      # activate the party window
      @party_window.active = true
    end
                         
  end
                       
end

#==============================================================================
# Window_SwitchParty class definition
#------------------------------------------------------------------------------
# A window that displays all 4 character slots in the party, and offers a
# cursor to modify it.
#
# By exseiken, October 04, 2004
#==============================================================================
class Window_SwitchParty < Window_Selectable
                       
  #----------------------------------------------------------------------------
  # Create public access variables
  #----------------------------------------------------------------------------
  attr_reader :new_party # The party shown in the window [R-O]
                       
  #----------------------------------------------------------------------------
  # Window's constructor. Create the window's contents, makes a copy of the
  # current party, then stocks it into member variable new_party, for later
  # use.
  #----------------------------------------------------------------------------
  def initialize()
    # create the window and its contents
    super(0, 0, 256, 480)
    self.contents = Bitmap.new(width - 32, height - 32)
    self.contents.font.name = $fontface
    self.contents.font.size = $fontsize
    # copy the party
    @new_party = $game_party.actors.clone
    # always 4 party members
    @item_max = 4
    # select the first character
    if @new_party.size > 0
      @index = @new_party.index(@new_party.first )
    else
      @index = 0
    end
    # draw the window's contents
    refresh
    # update the cursor rectangle
    update_cursor_rect
  end
                       
                       
  #----------------------------------------------------------------------------
  # Return the actor currently selected.
  #----------------------------------------------------------------------------
  def actor
    # return the selected actor, or nil if none
    @new_party[@index]
  end
                       
                         
  #----------------------------------------------------------------------------
  # Update the contents of the window: clear the contents bitmap, then rebuild
  # it.
  #----------------------------------------------------------------------------
  def refresh
    # clear the contents of the bitmap
    self.contents.clear
    # draw each non-null party member
    for i in 0..@new_party.size - 1
      # get the actor
      actor = @new_party[i]
      # if the actor is valid, draw it on the screen
      if actor != nil
        # calculate the y coordinate
        y = 116 * i       
        # draw the actor's graphic
        draw_actor_graphic(actor, 24, y + 80)
        # draw the actor's name
        draw_actor_name(actor, 64, y + 32)                               
      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)
    self.contents.font.name = $fontface
    self.contents.font.size = $fontsize
    # 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)
    self.contents.font.name = $fontface
    self.contents.font.size = $fontsize
  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
    def draw_actor_face(actor, x, y)
    end
    draw_actor_face(actor, x - 200, y + 80)
    # draw the actor's name, level
    draw_actor_name(actor, 114, 0)
    draw_actor_level(actor, 188, 0)
    # draw_actor_hp_meter_line(actor, x + -145, y + 50, width = 133, height = 8)
    draw_actor_hp(actor, 114, 32)
    # draw_actor_sp_meter_line(actor, x + -145, y + 80, width = 133, height = 8)
    draw_actor_sp(actor, 114, 64)
  end
                           
end

#==============================================================================
# ¦ Scene_Menu
#------------------------------------------------------------------------------
# ??????????????????
#==============================================================================
class Scene_Menu
 
  #--------------------------------------------------------------------------
  # ? ?????????
  # menu_index : ?????????????
  #--------------------------------------------------------------------------
  def initialize(menu_index = 0)
    @menu_index = menu_index
  end

  #--------------------------------------------------------------------------
  # ? ?????
  #--------------------------------------------------------------------------
  def main
    # ????????????
    s1 = $data_system.words.item
    s2 = $data_system.words.skill
    s3 = $data_system.words.equip
    s4 = "État"
    s5 = "Réserve"
    s6 = "Sauvegarder"
    s7 = "Quitter"
    @command_window = Window_Command.new(160, [s1, s2, s3, s4, s5, s6,s7])
    @command_window.index = @menu_index
    # ??????? 0 ????
    if $game_party.actors.size == 0
      # ?????????????????????
      @command_window.disable_item(0)
      @command_window.disable_item(1)
      @command_window.disable_item(2)
      @command_window.disable_item(3)
    end
    # ????????
    if $game_system.save_disabled
      # ?????????
      @command_window.disable_item(4)
    end
    # ?????????????
    @playtime_window = Window_PlayTime.new
    @playtime_window.x = 0
    @playtime_window.y = 254
    # ??????????
    @steps_window = Window_Steps.new
    @steps_window.x = 0
    @steps_window.y = 333
    # ????????????
    @gold_window = Window_Gold.new
    @gold_window.x = 0
    @gold_window.y = 418
    # ?????????????
    @status_window = Window_MenuStatus.new
    @status_window.x = 160
    @status_window.y = 0
    # ?????????
    Graphics.transition
    # ??????
    loop do
      # ????????
      Graphics.update
      # ???????
      Input.update
      # ??????
      update
      # ????????????????
      if $scene != self
        break
      end
    end
    # ?????????
    Graphics.freeze
    # ????????
    @command_window.dispose
    @playtime_window.dispose
    @steps_window.dispose
    @gold_window.dispose
    @status_window.dispose
  end
 
  #--------------------------------------------------------------------------
  # ? ??????
  #--------------------------------------------------------------------------
  def update
    # ????????
    @command_window.update
    @playtime_window.update
    @steps_window.update
    @gold_window.update
    @status_window.update
    # ??????????????????: update_command ???
    if @command_window.active
      update_command
      return
    end
    # ???????????????????: update_status ???
    if @status_window.active
      update_status
      return
    end
  end
 
  #--------------------------------------------------------------------------
  # ? ?????? (??????????????????)
  #--------------------------------------------------------------------------
  def update_command
    # B ??????????
    if Input.trigger?(Input::B)
      # ????? SE ???
      $game_system.se_play($data_system.cancel_se)
      # ??????????
      $scene = Scene_Map.new
      return
    end
    # C ??????????
    if Input.trigger?(Input::C)
      # ??????? 0 ??????????????????????
      if $game_party.actors.size == 0 and @command_window.index < 4
        # ??? SE ???
        $game_system.se_play($data_system.buzzer_se)
        return
      end
      # ???????????????????
      case @command_window.index
      when 0 # ????
        # ?? SE ???
        $game_system.se_play($data_system.decision_se)
        # ???????????
        $scene = Scene_Item.new
      when 1 # ???
        # ?? SE ???
        $game_system.se_play($data_system.decision_se)
        # ???????????????????
        @command_window.active = false
        @status_window.active = true
        @status_window.index = 0
      when 2 # ??
        # ?? SE ???
        $game_system.se_play($data_system.decision_se)
        # ???????????????????
        @command_window.active = false
        @status_window.active = true
        @status_window.index = 0
      when 3 # ?????
        # ?? SE ???
        $game_system.se_play($data_system.decision_se)
        # ???????????????????
        @command_window.active = false
        @status_window.active = true
        @status_window.index = 0
      when 4 # ?????
        # ?? SE ???
        $game_system.se_play($data_system.decision_se)
        # ????????????
        $scene = Scene_Switch.new(@status_window.index)
      when 5 # ???
        # ????????
        if $game_system.save_disabled
          # ??? SE ???
          $game_system.se_play($data_system.buzzer_se)
          return
        end
        # ?? SE ???
        $game_system.se_play($data_system.decision_se)
        # ??????????
        $scene = Scene_Save.new
      when 6 # ?????
        # ?? SE ???
        $game_system.se_play($data_system.decision_se)
        # ????????????
        $scene = Scene_End.new
      end
      return
    end
  end
 
  #--------------------------------------------------------------------------
  # ? ?????? (???????????????????)
  #--------------------------------------------------------------------------
  def update_status
    # B ??????????
    if Input.trigger?(Input::B)
      # ????? SE ???
      $game_system.se_play($data_system.cancel_se)
      # ??????????????????
      @command_window.active = true
      @status_window.active = false
      @status_window.index = -1
      return
    end
    # C ??????????
    if Input.trigger?(Input::C)
      # ???????????????????
      case @command_window.index
      when 1 # ???
        # ???????????? 2 ?????
        if $game_party.actors[@status_window.index].restriction >= 2
          # ??? SE ???
          $game_system.se_play($data_system.buzzer_se)
          return
        end
        # ?? SE ???
        $game_system.se_play($data_system.decision_se)
        # ??????????
        $scene = Scene_Skill.new(@status_window.index)
      when 2 # ??
        # ?? SE ???
        $game_system.se_play($data_system.decision_se)
        # ?????????
        $scene = Scene_Equip.new(@status_window.index)
      when 3 # ?????
        # ?? SE ???
        $game_system.se_play($data_system.decision_se)
        # ????????????
        $scene = Scene_Status.new(@status_window.index)
      end
      return
    end
  end
 
end