Party (Help) Options

[CloudUxeeth]

So i'm kinda new to Rpg maker but I just started with a project and I would like to have 4 playable characters as it is. But also a menu option to change order of the character.

With it I would also like that then you enter battle you have the 3 first characters enter the battle instead of all 4. Would love to have help with this.

This post has been edited by CloudUxeeth: Jun 21 2012, 02:39 PM

[Kaleb Daub]

what engine are you using if Vx I have a easy solution. If not tell me what engine and what scripts you are using involving battle and party.

This post has been edited by mooshra: Jun 21 2012, 04:09 PM

[CloudUxeeth]

what engine are you using if Vx I have a easy solution. If not tell me what engine and what scripts you are using involving battle and party.

I'm using Vx yes:) I use RSSBS - Reedo's Simple Side Battle System only atm.

[kaz]

So i'm kinda new to Rpg maker but I just started with a project and I would like to have 4 playable characters as it is. But also a menu option to change order of the character.

With it I would also like that then you enter battle you have the 3 first characters enter the battle instead of all 4. Would love to have help with this.

This is for Forum feedback not game help. Moving this to VX.

[Kaleb Daub]

OK use this script this script lets you have up to 99 playable characters and switch ones in and out of battle and which ones are reserves. you can decide what to call the command in menu and battle or disable it in either you can also you this as a easy way to decide how many can go into battle as well I have it set to where only three people can battle but if you look the script over its real easy to config. It is called KGC lage party so credit KGC for the script. And credit Mr. Bubble and Mr. Anonymous for translating it from Japanese.

CODE

#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_
#_/    â—†     Party Expansion & Formation - KGC_LargeParty      â—† VX â—†
#_/    â—‡                 Last Update: 2009/11/01                    â—‡
#_/    â—†           Translation by Mr. Anonymous & Mr. Bubble        â—†

#_/-----------------------------------------------------------------------------
#_/  This script allows you more control over the default "party" system by
#_/   removing the limitation of only having four actors to a party. These
#_/   extra actors may behave just as any other actor during battle. In addition
#_/   you may also have "standby" actors, who can be swapped out with the
#_/   current party via a "Party Formation" screen, which may optionally be
#_/   added into the main menu panel, and/or even called from pressing
#_/   a specified button while on the main menu.
#_/-----------------------------------------------------------------------------
#_/                       â—† 2009/11/01 UPDATE [KGC] â—†
#_/             New Script Commands added. New functionality added for
#_/             deploying standby members into battle after the party
#_/             is defeated.
#_/=============================================================================
#_/                    â—† Instructions For Usage â—†
#_/                       â—† Script Commands â—†
#_/  These commands are used in "Script" function in the third page of event
#_/   commands under "Advanced".
#_/
#_/  * call_partyform
#_/     Calls the Party Formation screen.
#_/
#_/  * set_max_battle_member_count(Value)
#_/     Allows you to manually set the maximum amount of actors in the active
#_/      party, i.e. the amount of party members who may participate in battle.
#_/
#_/  * get_all_member_count(variable_id)
#_/     Stores the combined total of party members and standby members into
#_/      the specified variable_id number.
#_/
#_/  * get_battle_member_count(variable_id)
#_/     Stores the number of battle members the specified variable_id number.
#_/      This DOES NOT include standby members.
#_/
#_/  * get_stand_by_member_count(variable_id)
#_/     Stores the number of standby members the specified variable_id number.
#_/      This DOES NOT include battle members.
#_/
#_/  * party_full?
#_/     Used for Conditional Branches. This allows you to determine whether the
#_/      active party is full in accordance to MAX_BATTLE_MEMBERS or the above
#_/      manual statement of set_max_battle_member_count(Value).
#_/
#_/  * permit_partyform(true/false)
#_/     Allows you to enable or disable the Party Formation screen on the main
#_/      command menu. This also actives or deactivates FORM_SWITCHPARTY.
#_/
#_/  * fix_actor(ActorID, true/false)
#_/     Allows you to fix or force an actor into remaining in the active party
#_/      and not be switched out with a standby actor. If the true/false
#_/      argument is omitted, the statement is automatically considered true.
#_/  
#_/  * change_party_shift(index1, index2)
#_/     This allows you to switch an actor in the position of index1 with the
#_/      actor in the position of index2. This ignores the fix_actor function.
#_/       Also of note is that the first actor in the party actually has an
#_/       index of 0, second actor has an index of 1, and so on.
#_/
#_/  * sort_party_member(sort_type, true/false)
#_/     This allows you to manually sort the actors by replacing sort_type with
#_/      SORT_BY_ID, SORT_BY_NAME, or SORT_BY_LEVEL. If you set the second
#_/      argument to true, the sorting order is reversed. If true, it is not.
#_/      Also, if the second argument is omitted, it is automatically false.
#_/
#_/  * get_stand_by_member_ids
#_/     This acquires the arrangement of the ActorIDs of the standby actors.
#_/
#_/  * stand_by_member?(ActorID)
#_/     Used for Conditional Branches. This allows you to determine if the actor
#_/      specified is a standby party member.
#_/
#_/  * add_battle_member(ActorID, index)
#_/     Allows you to add an actor to the active party and place it in the
#_/      desired position(index). If the second argument is omitted, the actor
#_/      will automatically be placed at the end of the party. Also, if the
#_/      active party is full, the actor will not be added.
#_/
#_/  * remove_battle_member(ActorID)
#_/     Removes an actor from the active party. This cannot removed an actor
#_/      who is fixed into place using fix_actor.
#_/
#_/  * remove_all_battle_member
#_/     All actors other than fixed actors are removed from the active party.
#_/      Note that this seems to unfix fixed characters, but not remove them.
#_/      Also note that if there are no fixed actors, you must add a member
#_/      back into the active party using add_battle_member BEFORE the player
#_/      is allowed to open the menu or enter battle.
#_/
#_/  * random_launch
#_/     Randomly sorts and replaces the active party with those from the standby
#_/      party. Once again this does not effect fixed actors.
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_

#==============================================================================
# ★ Customize BEGIN ★
#==============================================================================

module KGC
module LargeParty
  #                  â—† Party Formation In-Game Switch â—†
  #  This allows you to assign an in-game Switch that allows you to enable or
  #   disable the Party Formation screen on the main command menu.
  PARTYFORM_SWITCH          = 98
  #                  â—† Party Formation In-Game Switch â—†
  #  This allows you to assign an in-game Switch that allows you to enable or
  #   disable the Party Formation screen on the main command menu.
  BATTLE_PARTYFORM_SWITCH   = 99
  #            â—† Default Party Formation Switch Activation Toggle â—†
  #  When "New Game" is selected, both party formation permission switches
  #   automatically become active (ON) when this is set as true.
  DEFAULT_PARTYFORM_ENABLED = false

  #                  â—† Maximum Party Members (In Combat) â—†
  #  Allows you to choose how many actors may participate in a battle.
  MAX_BATTLE_MEMBERS = 3
  #                         â—† The Party Members â—†
  #  Allows you to choose how many actors may be added to the party.
  #   *Note: Game_Party::MAX_MEMBERS Is overwritten
  #  When making this 100 or more, you'll receive an error.
  MAX_MEMBERS = 98

  #                     â—† Fixed Party Member Sorting â—†
  #  This toggle allows you to enable/disable automatic sorting of fixed(active)
  #   party members.
  #  true = Disable automatic sorting.
  #  false = Enable automatic sorting.
  FORBID_CHANGE_SHIFT_FIXED = true

  #  Standby Members Background Color
  #   Default: Color.new(0, 0, 0, 0)
  STAND_BY_COLOR = Color.new(0, 0, 0, 128)
  # â—† Fixed Current Party Background Color
  FIXED_COLOR    = Color.new(255, 128, 64, 96)
  #  Background Color that shows when Members are selected.
  SELECTED_COLOR = Color.new(64, 255, 128, 128)

  #                â—† Party Formation Command Menu Selection â—†
  #  This allows you to change the key/button pressed in the menu screen to
  #   pull up the Party Formation screen without actually highlighting and
  #   selecting the Party Formation option.
  #  If this is set as nil, this function is disabled.
  MENU_PARTYFORM_BUTTON      = Input::A
  #  This toggle allows you to enable/disable the Party Formation option on the
  #   main command window.
  # true = The option is enabled.
  # false = The option is removed.
  USE_MENU_PARTYFORM_COMMAND = true
  #  This allows you to change the text displayed for the Party Formation option
  #   in the main command window.
  VOCAB_MENU_PARTYFORM       = "Formation"

  #  This toggle allows you to enable/disable the Party Formation option while
  #   in combat.
  #   This option is added under the "Run" or "Escape" command.
  USE_BATTLE_PARTYFORM   = true
  #  This allows you to change the text displayed for the Party Formation option
  #   while in combat under the "Run" or "Escape" command.
  VOCAB_BATTLE_PARTYFORM = "Foramtion"

  # â—† Automatic Party Switching in Battles
  #   true  : Actors in reserve will replace the defeated party members
  #           and the battle will continue.
  #   false : End the battle if the whole party is defeated.
  ENABLE_DEFEAT_LAUNCH  = false
  # â—† Message Display For Defeated Party Switch
  #  %s : Party member's name
  DEFEAT_LAUNCH_MESSAGE = "%s entered the battle!"

  #           â—† Party Formation Screen Character Dimensions â—†
  #  This allows you to change the width and height of the actors' placemarkers
  #   on the Party Formation Screen.
  #  You can rewrite this [x, y] in accordance to the size of your actor's
  #   walking graphic.
  PARTY_FORM_CHARACTER_SIZE   = [40, 48]
  #  This allows you to change the text of the empty slots in the Party
  #   Formation Screen.
  BATTLE_MEMBER_BLANK_TEXT    = "EMPTY"
  # â—† Party Formation Screen Member Rows â—†
  #  This allows you to change the amount of rows that in the "Standby"
  #   box.
  #  Adjust this value to 1 if the status window protrudes beyond the screen.
  PARTY_MEMBER_WINDOW_ROW_MAX = 2
  #                     â—† Current Party Member Display â—†
  #  This toggle allows you to show/hide the current party members in the
  #   "Standby" box.
  #  true = Show them! These will be greyed out.
  #  false = Hide them.
  SHOW_BATTLE_MEMBER_IN_PARTY = false
  #  This allows you to change the text displayed for empty slots on in the
  #   "Current Party" box.
  PARTY_MEMBER_BLANK_TEXT     = "-"

  # â—† Width of caption window on organization screen
  CAPTION_WINDOW_WIDTH  = 192
  # â—† Caption of combat member window on organization screen
  BATTLE_MEMBER_CAPTION = "Current Party"

  if SHOW_BATTLE_MEMBER_IN_PARTY
    #  This allows you to change the text that appears on top of the Party
    #   Formation box.
    #  (When SHOW_BATTLE_MEMBER_IN_PARTY = true)
    PARTY_MEMBER_CAPTION = "Party Formation"
  else
    #  This allows you to change the text that appears on top of the Standby
    #    box.
    #  (When SHOW_BATTLE_MEMBER_IN_PARTY = false)
    PARTY_MEMBER_CAPTION = "Standby"
  end

  #                â—† Width of Formation Confirmation Window â—†
  CONFIRM_WINDOW_WIDTH    = 160
  #             â—† Vocab Strings for Formation Confirmation Window â—†
  #  If the order of these commands are changed or something is removed, expect
  #   an error.
  CONFIRM_WINDOW_COMMANDS = ["Done", "Menu", "Cancel"]

  #                   â—† Equip Item Status Shop Scroll â—†
  #  This allows you to change the key/button HELD DOWN while using the Up and
  #   Down keys to scroll the attribute bonuses window (to the right) to view
  #   the each individual unit's attribute bonuses. KCG_HelpExtension is
  #   required for this function to work properly.
  #  If you set this to nil, this function is disabled.
  SHOP_STATUS_SCROLL_BUTTON = Input::A

  #               â—† Standby Members Experience Gain Percentage â—†
  #  If you enter 500 in this, the actual EXP gained is 50.0%
  #   You may also prevent standby units from gaining EXP by setting this is 0.
  STAND_BY_EXP_RATE = 500
  #                    â—† Standby Members Level-Up Message â—†
  #  This toggle allows you to enable/disable the level-up messages displayed
  #   for units on standby.
  #  true = Show level-up messages for standby units.
  #  false = Hide level-up messages for standby units.
  SHOW_STAND_BY_LEVEL_UP = true
  #                   â—† Standby Members Menu Status Display â—†
  #  Allows you to view the menu status of standby members whether
  #   they are in the main party or not. This also includes the equip scene.
  #  true  : Show standby members in the menu.
  #  false : Standby member status and equipment cannot be seen.
  SHOW_STAND_BY_MEMBER_NOT_IN_BATTLE = true
end
end

#==============================================================================
# ☆ Customize END ☆
#==============================================================================

$imported = {} if $imported == nil
$imported["LargeParty"] = true

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆ï
¿½
��
��☆★☆★☆★☆★☆★☆★

#==============================================================================
# â–¡ KGC::Commands
#==============================================================================

module KGC
module Commands
  # メンãƒ�ーã�®ã‚½ãƒ¼ãƒˆå½¢å¼�
  SORT_BY_ID    = 0  # IDé †
  SORT_BY_NAME  = 1  # å��å‰�é †
  SORT_BY_LEVEL = 2  # レベル順

  module_function
  #--------------------------------------------------------------------------
  # â—‹ パーティ編æˆ�ç”»é�¢ã�®å‘¼ã�³å‡ºã�—
  #--------------------------------------------------------------------------
  def call_partyform
    return if $game_temp.in_battle
    $game_temp.next_scene = :partyform
  end
  #--------------------------------------------------------------------------
  # â—‹ 戦闘メンãƒ�ー最大数を設定
  #     value : 人数 (çœ�ç•¥ã�—ã�Ÿå ´å�ˆã�¯ãƒ‡ãƒ•ã‚©ãƒ«ãƒˆå€¤ã‚’使用)
  #--------------------------------------------------------------------------
  def set_max_battle_member_count(value = nil)
    $game_party.max_battle_member_count = value
  end
  #--------------------------------------------------------------------------
  # â—‹ 全メンãƒ�ー数å�–å¾—
  #     variable_id : å�–å¾—ã�—ã�Ÿå€¤ã‚’代入ã�™ã‚‹å¤‰æ•°ã�® ID
  #--------------------------------------------------------------------------
  def get_all_member_count(variable_id = 0)
    n = $game_party.all_members.size
    if variable_id > 0
      $game_variables[variable_id] = n
      $game_map.need_refresh = true
    end
    return n
  end
  #--------------------------------------------------------------------------
  # â—‹ 戦闘メンãƒ�ー数å�–å¾—
  #     variable_id : å�–å¾—ã�—ã�Ÿå€¤ã‚’代入ã�™ã‚‹å¤‰æ•°ã�® ID
  #--------------------------------------------------------------------------
  def get_battle_member_count(variable_id = 0)
    n = $game_party.battle_members.size
    if variable_id > 0
      $game_variables[variable_id] = n
      $game_map.need_refresh = true
    end
    return n
  end
  #--------------------------------------------------------------------------
  # â—‹ 待機メンãƒ�ー数å�–å¾—
  #     variable_id : å�–å¾—ã�—ã�Ÿå€¤ã‚’代入ã�™ã‚‹å¤‰æ•°ã�® ID
  #--------------------------------------------------------------------------
  def get_stand_by_member_count(variable_id = 0)
    n = $game_party.stand_by_members.size
    if variable_id > 0
      $game_variables[variable_id] = n
      $game_map.need_refresh = true
    end
    return n
  end
  #--------------------------------------------------------------------------
  # â—‹ パーティ人数ã�Œä¸€æ�¯ã�‹
  #--------------------------------------------------------------------------
  def party_full?
    return $game_party.full?
  end
  #--------------------------------------------------------------------------
  # â—‹ パーティ編æˆ�å�¯å�¦ã‚’設定
  #     enabled : 有効フラグ (çœ�略時 : true)
  #--------------------------------------------------------------------------
  def permit_partyform(enabled = true)
    $game_switches[KGC::LargeParty::PARTYFORM_SWITCH] = enabled
  end
  #--------------------------------------------------------------------------
  # â—‹ 戦闘中ã�®ãƒ‘ーティ編æˆ�å�¯å�¦ã‚’設定
  #     enabled : 有効フラグ (çœ�略時 : true)
  #--------------------------------------------------------------------------
  def permit_battle_partyform(enabled = true)
    $game_switches[KGC::LargeParty::BATTLE_PARTYFORM_SWITCH] = enabled
  end
  #--------------------------------------------------------------------------
  # â—‹ アクターã�®å›ºå®šçŠ¶æ…‹ã‚’設定
  #     actor_id : アクター ID
  #     fixed    : 固定フラグ (çœ�略時 : true)
  #--------------------------------------------------------------------------
  def fix_actor(actor_id, fixed = true)
    $game_party.fix_actor(actor_id, fixed)
  end
  #--------------------------------------------------------------------------
  # â—‹ 並ã�³æ›¿ã�ˆ
  #    ãƒ¡ãƒ³ãƒ�ーã�® index1 番目ã�¨ index2 番目を入れ替ã�ˆã‚‹
  #--------------------------------------------------------------------------
  def change_party_shift(index1, index2)
    $game_party.change_shift(index1, index2)
  end
  #--------------------------------------------------------------------------
  # â—‹ メンãƒ�ー整列 (昇順)
  #     sort_type : ソート形å¼� (SORT_BY_xxx)
  #     reverse   : true ã� ã�¨é™�é †
  #--------------------------------------------------------------------------
  def sort_party_member(sort_type = SORT_BY_ID, reverse = false)
    $game_party.sort_member(sort_type, reverse)
  end
  #--------------------------------------------------------------------------
  # â—‹ 待機メンãƒ�ーã�® ID ã‚’å�–å¾—
  #--------------------------------------------------------------------------
  def get_stand_by_member_ids
    result = []
    $game_party.stand_by_members.each { |actor| result << actor.id }
    return result
  end
  #--------------------------------------------------------------------------
  # â—‹ アクターã�Œå¾…機メンãƒ�ーã�‹
  #     actor_id : アクター ID
  #--------------------------------------------------------------------------
  def stand_by_member?(actor_id)
    return get_stand_by_member_ids.include?(actor_id)
  end
  #--------------------------------------------------------------------------
  # â—‹ アクターを戦闘メンãƒ�ーã�«åŠ ã�ˆã‚‹
  #     actor_id : アクター ID
  #     index    : 追加ä½�ç½® (çœ�略時ã�¯æœ€å¾Œå°¾)
  #--------------------------------------------------------------------------
  def add_battle_member(actor_id, index = nil)
    $game_party.add_battle_member(actor_id, index)
  end
  #--------------------------------------------------------------------------
  # â—‹ アクターを戦闘メンãƒ�ーã�‹ã‚‰å¤–ã�™
  #     actor_id : アクター ID
  #--------------------------------------------------------------------------
  def remove_battle_member(actor_id)
    $game_party.remove_battle_member(actor_id)
  end
  #--------------------------------------------------------------------------
  # â—‹ 固定アクター以外を戦闘メンãƒ�ーã�‹ã‚‰å¤–ã�™
  #--------------------------------------------------------------------------
  def remove_all_battle_member
    $game_party.remove_all_battle_member
  end
  #--------------------------------------------------------------------------
  # â—‹ ランダム出撃
  #--------------------------------------------------------------------------
  def random_launch
    new_battle_members = $game_party.fixed_members
    candidates = $game_party.all_members - new_battle_members
    num = [$game_party.max_battle_member_count - new_battle_members.size,
      candidates.size].min
    return if num <= 0

    # ランダムã�«é�¸ã�¶
    ary = (0...candidates.size).to_a.sort_by { rand }
    ary[0...num].each { |i| new_battle_members << candidates[i] }
    $game_party.set_battle_member(new_battle_members)
  end
end
end

class Game_Interpreter
  include KGC::Commands
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆ï
¿½
��
��☆★☆★☆★☆★☆★☆★

#==============================================================================
# â–  Vocab
#==============================================================================

module Vocab
  # 全滅時ã�®å…¥ã‚Œæ›¿ã�ˆãƒ¡ãƒƒã‚»ãƒ¼ã‚¸
  DefeatLaunch = KGC::LargeParty::DEFEAT_LAUNCH_MESSAGE

  # 「パーティ編æˆ�ã€�コマンドå�� (メニュー)
  def self.partyform
    return KGC::LargeParty::VOCAB_MENU_PARTYFORM
  end

  # 「パーティ編æˆ�ã€�コマンドå�� (戦闘)
  def self.partyform_battle
    return KGC::LargeParty::VOCAB_BATTLE_PARTYFORM
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆ï
¿½
��
��☆★☆★☆★☆★☆★☆★

#==============================================================================
# â–  Game_Actor
#==============================================================================

class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # â—‹ パーティ内インデックスå�–å¾—
  #--------------------------------------------------------------------------
  def party_index
    return $game_party.all_members.index(self)
  end
  #--------------------------------------------------------------------------
  # â—‹ 戦闘メンãƒ�ーã�‹åˆ¤å®š
  #--------------------------------------------------------------------------
  def battle_member?
    return $game_party.battle_members.include?(self)
  end
  #--------------------------------------------------------------------------
  # â—‹ 固定メンãƒ�ーã�‹åˆ¤å®š
  #--------------------------------------------------------------------------
  def fixed_member?
    return $game_party.fixed_members.include?(self)
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆ï
¿½
��
��☆★☆★☆★☆★☆★☆★

#==============================================================================
# â–  Game_Party
#==============================================================================

class Game_Party
  #--------------------------------------------------------------------------
  # â—� 定数
  #--------------------------------------------------------------------------
  MAX_MEMBERS = KGC::LargeParty::MAX_MEMBERS  # 最大パーティ人数
  #--------------------------------------------------------------------------
  # â—� オブジェクトåˆ�期化
  #--------------------------------------------------------------------------
  alias initialize_KGC_LargeParty initialize
  def initialize
    initialize_KGC_LargeParty

    @max_battle_member_count = nil
    @battle_member_count = 0
    @fixed_actors = []
  end
  #--------------------------------------------------------------------------
  # â—‹ 戦闘メンãƒ�ー最大数å�–å¾—
  #--------------------------------------------------------------------------
  def max_battle_member_count
    if @max_battle_member_count == nil
      return KGC::LargeParty::MAX_BATTLE_MEMBERS
    else
      return @max_battle_member_count
    end
  end
  #--------------------------------------------------------------------------
  # â—‹ 戦闘メンãƒ�ー最大数変更
  #--------------------------------------------------------------------------
  def max_battle_member_count=(value)
    if value.is_a?(Integer)
      value = [value, 1].max
    end
    @max_battle_member_count = value
  end
  #--------------------------------------------------------------------------
  # â—‹ 戦闘メンãƒ�ー数å�–å¾—
  #--------------------------------------------------------------------------
  def battle_member_count
    if @battle_member_count == nil
      @battle_member_count = @actors.size
    end
    @battle_member_count =
      [@battle_member_count, @actors.size, max_battle_member_count].min
    return @battle_member_count
  end
  #--------------------------------------------------------------------------
  # â—‹ 戦闘メンãƒ�ー数設定
  #--------------------------------------------------------------------------
  def battle_member_count=(value)
    @battle_member_count = [[value, 0].max,
      @actors.size, max_battle_member_count].min
  end
  #--------------------------------------------------------------------------
  # â—� メンãƒ�ーã�®å�–å¾—
  #--------------------------------------------------------------------------
  alias members_KGC_LargeParty members
  def members
    if $game_temp.in_battle ||
        !KGC::LargeParty::SHOW_STAND_BY_MEMBER_NOT_IN_BATTLE
      return battle_members
    else
      return members_KGC_LargeParty
    end
  end
  #--------------------------------------------------------------------------
  # â—‹ 全メンãƒ�ーã�®å�–å¾—
  #--------------------------------------------------------------------------
  def all_members
    return members_KGC_LargeParty
  end
  #--------------------------------------------------------------------------
  # â—‹ 戦闘メンãƒ�ーã�®å�–å¾—
  #--------------------------------------------------------------------------
  def battle_members
    result = []
    battle_member_count.times { |i| result << $game_actors[@actors[i]] }
    return result
  end
  #--------------------------------------------------------------------------
  # â—‹ 待機メンãƒ�ーã�®å�–å¾—
  #--------------------------------------------------------------------------
  def stand_by_members
    return (all_members - battle_members)
  end
  #--------------------------------------------------------------------------
  # â—‹ 固定メンãƒ�ーã�®å�–å¾—
  #--------------------------------------------------------------------------
  def fixed_members
    result = []
    @fixed_actors.each { |i| result << $game_actors[i] }
    return result
  end
  #--------------------------------------------------------------------------
  # â—� åˆ�期パーティã�®ã‚»ãƒƒãƒˆã‚¢ãƒƒãƒ—
  #--------------------------------------------------------------------------
  alias setup_starting_members_KGC_LargeParty setup_starting_members
  def setup_starting_members
    setup_starting_members_KGC_LargeParty

    self.battle_member_count = @actors.size
  end
  #--------------------------------------------------------------------------
  # â—� 戦闘テスト用パーティã�®ã‚»ãƒƒãƒˆã‚¢ãƒƒãƒ—
  #--------------------------------------------------------------------------
  alias setup_battle_test_members_KGC_LargeParty setup_battle_test_members
  def setup_battle_test_members
    setup_battle_test_members_KGC_LargeParty

    self.battle_member_count = @actors.size
  end
  #--------------------------------------------------------------------------
  # â—‹ メンãƒ�ーã�®æ–°è¦�設定
  #     new_member : æ–°ã�—ã�„メンãƒ�ー
  #--------------------------------------------------------------------------
  def set_member(new_member)
    @actors = []
    new_member.each { |actor| @actors << actor.id }
  end
  #--------------------------------------------------------------------------
  # â—‹ 戦闘メンãƒ�ーã�®æ–°è¦�設定
  #     new_member : æ–°ã�—ã�„戦闘メンãƒ�ー
  #--------------------------------------------------------------------------
  def set_battle_member(new_member)
    new_battle_member = []
    new_member.each { |actor|
      @actors.delete(actor.id)
      new_battle_member << actor.id
    }
    @actors = new_battle_member + @actors
    self.battle_member_count = new_member.size
  end
  #--------------------------------------------------------------------------
  # â—‹ パーティ編æˆ�を許å�¯ã�—ã�¦ã�„ã‚‹ã�‹åˆ¤å®š
  #--------------------------------------------------------------------------
  def partyform_enable?
    return $game_switches[KGC::LargeParty::PARTYFORM_SWITCH]
  end
  #--------------------------------------------------------------------------
  # â—‹ 戦闘中ã�®ãƒ‘ーティ編æˆ�を許å�¯ã�—ã�¦ã�„ã‚‹ã�‹åˆ¤å®š
  #--------------------------------------------------------------------------
  def battle_partyform_enable?
    return false unless partyform_enable?
    return $game_switches[KGC::LargeParty::BATTLE_PARTYFORM_SWITCH]
  end
  #--------------------------------------------------------------------------
  # â—‹ メンãƒ�ーã�Œä¸€æ�¯ã�‹åˆ¤å®š
  #--------------------------------------------------------------------------
  def full?
    return (@actors.size >= MAX_MEMBERS)
  end
  #--------------------------------------------------------------------------
  # â—‹ 出撃中ã�‹åˆ¤å®š
  #     actor_id : 判定ã�™ã‚‹ã‚¢ã‚¯ã‚¿ãƒ¼ã�® ID
  #--------------------------------------------------------------------------
  def actor_launched?(actor_id)
    return battle_members.include?($game_actors[actor_id])
  end
  #--------------------------------------------------------------------------
  # â—‹ 固定アクターã�‹åˆ¤å®š
  #     actor_id : 判定ã�™ã‚‹ã‚¢ã‚¯ã‚¿ãƒ¼ã�® ID
  #--------------------------------------------------------------------------
  def actor_fixed?(actor_id)
    return @fixed_actors.include?(actor_id)
  end
  #--------------------------------------------------------------------------
  # â—� アクターを加ã�ˆã‚‹
  #     actor_id : アクター ID
  #--------------------------------------------------------------------------
  alias add_actor_KGC_LargeParty add_actor
  def add_actor(actor_id)
    last_size = @actors.size

    add_actor_KGC_LargeParty(actor_id)

    if last_size < @actors.size
      self.battle_member_count += 1
    end
  end
  #--------------------------------------------------------------------------
  # â—‹ アクターを戦闘メンãƒ�ーã�«åŠ ã�ˆã‚‹
  #     actor_id : アクター ID
  #     index    : 追加ä½�ç½® (çœ�略時ã�¯æœ€å¾Œå°¾)
  #--------------------------------------------------------------------------
  def add_battle_member(actor_id, index = nil)
    return unless @actors.include?(actor_id)  # パーティã�«ã�„ã�ªã�„
    if index == nil
      return if battle_members.include?($game_actors[actor_id])  # 出撃済ã�¿
      return if battle_member_count == max_battle_member_count   # 人数ã�Œæœ€å¤§
      index = battle_member_count
    end

    @actors.delete(actor_id)
    @actors.insert(index, actor_id)
    self.battle_member_count += 1
  end
  #--------------------------------------------------------------------------
  # â—‹ アクターを戦闘メンãƒ�ーã�‹ã‚‰å¤–ã�™
  #     actor_id : アクター ID
  #--------------------------------------------------------------------------
  def remove_battle_member(actor_id)
    return unless @actors.include?(actor_id)  # パーティã�«ã�„ã�ªã�„
    return if actor_fixed?(actor_id)          # 固定済ã�¿
    return unless actor_launched?(actor_id)   # 待機中

    @actors.delete(actor_id)
    @actors.push(actor_id)
    self.battle_member_count -= 1
  end
  #--------------------------------------------------------------------------
  # â—‹ アクターã�®å›ºå®šçŠ¶æ…‹ã‚’設定
  #     actor_id : アクター ID
  #     fixed    : 固定フラグ (çœ�略時 : false)
  #--------------------------------------------------------------------------
  def fix_actor(actor_id, fixed = false)
    return unless @actors.include?(actor_id)  # パーティã�«ã�„ã�ªã�„

    if fixed
      # 固定
      unless @fixed_actors.include?(actor_id)
        @fixed_actors << actor_id
        unless battle_members.include?($game_actors[actor_id])
          self.battle_member_count += 1
        end
      end
      # 強制出撃
      apply_force_launch
    else
      # 固定解除
      @fixed_actors.delete(actor_id)
    end
    $game_player.refresh
  end
  #--------------------------------------------------------------------------
  # â—‹ 強制出撃é�©ç”¨
  #--------------------------------------------------------------------------
  def apply_force_launch
    while (fixed_members - battle_members).size > 0
      # 固定状態ã�§ã�ªã�„メンãƒ�ーをé�©å½“ã�«æŒ�ã�£ã�¦ã��ã�¦å…¥ã‚Œæ›¿ã�ˆ
      actor1 = stand_by_members.find { |a| @fixed_actors.include?(a.id) }
      actor2 = battle_members.reverse.find { |a| !@fixed_actors.include?(a.id) }
      index1 = @actors.index(actor1.id)
      index2 = @actors.index(actor2.id)
      @actors[index1], @actors[index2] = @actors[index2], @actors[index1]

      # 戦闘メンãƒ�ーã�Œå…¨å“¡å›ºå®šã�•ã‚Œã�Ÿã‚‰æˆ»ã‚‹ (ç„¡é™�ループ防止)
      all_fixed = true
      battle_members.each { |actor|
        unless actor.fixed_member?
          all_fixed = false
          break
        end
      }
      break if all_fixed
    end
  end
  #--------------------------------------------------------------------------
  # â—‹ 固定アクター以外を戦闘メンãƒ�ーã�‹ã‚‰å¤–ã�™
  #--------------------------------------------------------------------------
  def remove_all_battle_member
    all_members.each { |actor|
      remove_battle_member(actor.id) if actor_launched?(actor.id)
    }
  end
  #--------------------------------------------------------------------------
  # â—‹ メンãƒ�ー整列 (昇順)
  #     sort_type : ソート形å¼� (SORT_BY_xxx)
  #     reverse   : true ã� ã�¨é™�é †
  #--------------------------------------------------------------------------
  def sort_member(sort_type = KGC::Commands::SORT_BY_ID,
                  reverse = false)
    # ãƒ�ッファを準備
    b_actors = battle_members
    actors   = all_members - b_actors
    f_actors = fixed_members
    # 固定キャラã�¯ã‚½ãƒ¼ãƒˆã�—ã�ªã�„
    if KGC::LargeParty::FORBID_CHANGE_SHIFT_FIXED
      actors   -= f_actors
      b_actors -= f_actors
    end

    # ソート
    case sort_type
    when KGC::Commands::SORT_BY_ID     # IDé †
      actors.sort!   { |a, b| a.id <=> b.id }
      b_actors.sort! { |a, b| a.id <=> b.id }
    when KGC::Commands::SORT_BY_NAME   # å��å‰�é †
      actors.sort!   { |a, b| a.name <=> b.name }
      b_actors.sort! { |a, b| a.name <=> b.name }
    when KGC::Commands::SORT_BY_LEVEL  # レベル順
      actors.sort!   { |a, b| a.level <=> b.level }
      b_actors.sort! { |a, b| a.level <=> b.level }
    end
    # å��転
    if reverse
      actors.reverse!
      b_actors.reverse!
    end

    # 固定キャラを先頭ã�«æŒ�ã�£ã�¦ã��ã‚‹
    if KGC::LargeParty::FORBID_CHANGE_SHIFT_FIXED
      actors   = f_actors + actors
      b_actors = f_actors + b_actors
    end

    # 復帰
    set_member(actors)
    set_battle_member(b_actors)

    apply_force_launch
    $game_player.refresh
  end
  #--------------------------------------------------------------------------
  # â—‹ 並ã�³æ›¿ã�ˆ
  #    æˆ¦é—˜ãƒ¡ãƒ³ãƒ�ーã�® index1 番目ã�¨ index2 番目を入れ替ã�ˆã‚‹
  #--------------------------------------------------------------------------
  def change_shift(index1, index2)
    size = @actors.size
    if index1 >= size || index2 >= size
      return
    end
    buf = @actors[index1]
    @actors[index1] = @actors[index2]
    @actors[index2] = buf
    $game_player.refresh
  end
  #--------------------------------------------------------------------------
  # â—� 戦闘用ステートã�®è§£é™¤ (戦闘終了時ã�«å‘¼ã�³å‡ºã�—)
  #--------------------------------------------------------------------------
  def remove_states_battle
    (1...$data_actors.size).each { |i|
      $game_actors[i].remove_states_battle
    }
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆ï
¿½
��
��☆★☆★☆★☆★☆★☆★

#==============================================================================
# â–  Window_Command
#==============================================================================

class Window_Command < Window_Selectable
  unless method_defined?(:add_command)
  #--------------------------------------------------------------------------
  # â—‹ コマンドを追加
  #    è¿½åŠ ã�—ã�Ÿä½�置を返ã�™
  #--------------------------------------------------------------------------
  def add_command(command)
    @commands << command
    @item_max = @commands.size
    item_index = @item_max - 1
    refresh_command
    draw_item(item_index)
    return item_index
  end
  #--------------------------------------------------------------------------
  # â—‹ コマンドをリフレッシュ
  #--------------------------------------------------------------------------
  def refresh_command
    buf = self.contents.clone
    self.height = [self.height, row_max * WLH + 32].max
    create_contents
    self.contents.blt(0, 0, buf, buf.rect)
    buf.dispose
  end
  #--------------------------------------------------------------------------
  # â—‹ コマンドを挿入
  #--------------------------------------------------------------------------
  def insert_command(index, command)
    @commands.insert(index, command)
    @item_max = @commands.size
    refresh_command
    refresh
  end
  #--------------------------------------------------------------------------
  # â—‹ コマンドを削除
  #--------------------------------------------------------------------------
  def remove_command(command)
    @commands.delete(command)
    @item_max = @commands.size
    refresh
  end
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆ï
¿½
��
��☆★☆★☆★☆★☆★☆★

#==============================================================================
# â–  Window_MenuStatus
#==============================================================================

class Window_MenuStatus < Window_Selectable
  #--------------------------------------------------------------------------
  # â—� 定数
  #--------------------------------------------------------------------------
  STATUS_HEIGHT = 96  # ステータス一人分ã�®é«˜ã�•
  #--------------------------------------------------------------------------
  # â—� ウィンドウ内容ã�®ä½œæˆ�
  #--------------------------------------------------------------------------
  def create_contents
    self.contents.dispose
    self.contents = Bitmap.new(width - 32,
      [height - 32, row_max * STATUS_HEIGHT].max)
  end
  #--------------------------------------------------------------------------
  # â—� 先頭ã�®è¡Œã�®å�–å¾—
  #--------------------------------------------------------------------------
  def top_row
    return self.oy / STATUS_HEIGHT
  end
  #--------------------------------------------------------------------------
  # â—� 先頭ã�®è¡Œã�®è¨­å®š
  #     row : 先頭ã�«è¡¨ç¤ºã�™ã‚‹è¡Œ
  #--------------------------------------------------------------------------
  def top_row=(row)
    super(row)
    self.oy = self.oy / WLH * STATUS_HEIGHT
  end
  #--------------------------------------------------------------------------
  # â—� 1 ページã�«è¡¨ç¤ºã�§ã��る行数ã�®å�–å¾—
  #--------------------------------------------------------------------------
  def page_row_max
    return (self.height - 32) / STATUS_HEIGHT
  end
  #--------------------------------------------------------------------------
  # â—� 項目をæ��ç”»ã�™ã‚‹çŸ©å½¢ã�®å�–å¾—
  #     index : 項目番å�·
  #--------------------------------------------------------------------------
  def item_rect(index)
    rect = super(index)
    rect.height = STATUS_HEIGHT
    rect.y = index / @column_max * STATUS_HEIGHT
    return rect
  end
  #--------------------------------------------------------------------------
  # â—� リフレッシュ
  #--------------------------------------------------------------------------
  def refresh
    @item_max = $game_party.members.size
    create_contents
    fill_stand_by_background
    draw_member
  end
  #--------------------------------------------------------------------------
  # â—‹ パーティメンãƒ�ーæ��ç”»
  #--------------------------------------------------------------------------
  def draw_member
    for actor in $game_party.members
      draw_actor_face(actor, 2, actor.party_index * 96 + 2, 92)
      x = 104
      y = actor.party_index * 96 + WLH / 2
      draw_actor_name(actor, x, y)
      draw_actor_class(actor, x + 120, y)
      draw_actor_level(actor, x, y + WLH * 1)
      draw_actor_state(actor, x, y + WLH * 2)
      draw_actor_hp(actor, x + 120, y + WLH * 1)
      draw_actor_mp(actor, x + 120, y + WLH * 2)
    end
  end
  #--------------------------------------------------------------------------
  # â—‹ 待機メンãƒ�ーã�®èƒŒæ™¯è‰²ã‚’å¡—ã‚‹
  #--------------------------------------------------------------------------
  def fill_stand_by_background
    color = KGC::LargeParty::STAND_BY_COLOR
    dy = STATUS_HEIGHT * $game_party.battle_members.size
    dh = STATUS_HEIGHT * $game_party.stand_by_members.size
    if dh > 0
      self.contents.fill_rect(0, dy, self.width - 32, dh, color)
    end
  end
  #--------------------------------------------------------------------------
  # â—� カーソルã�®æ›´æ–°
  #--------------------------------------------------------------------------
  def update_cursor
    if @index < 0               # カーソルã�ªã�—
      self.cursor_rect.empty
    elsif @index < @item_max    # 通常
      super
    elsif @index >= 100         # 自分
      self.cursor_rect.set(0, (@index - 100) * STATUS_HEIGHT,
        contents.width, STATUS_HEIGHT)
    else                        # 全体
      self.cursor_rect.set(0, 0, contents.width, @item_max * STATUS_HEIGHT)
    end
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆ï
¿½
��
��☆★☆★☆★☆★☆★☆★

#==============================================================================
# â–  Window_ShopStatus
#==============================================================================

class Window_ShopStatus < Window_Base
  #--------------------------------------------------------------------------
  # â—� ウィンドウ内容ã�®ä½œæˆ�
  #--------------------------------------------------------------------------
  def create_contents
    self.contents.dispose
    self.contents = Bitmap.new(width - 32,
      WLH * ($game_party.members.size + 1) * 2)
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆ï
¿½
��
��☆★☆★☆★☆★☆★☆★

#==============================================================================
# â–  Window_BattleStatus
#==============================================================================

class Window_BattleStatus < Window_Selectable
  #--------------------------------------------------------------------------
  # â—� ウィンドウ内容ã�®ä½œæˆ�
  #--------------------------------------------------------------------------
  def create_contents
    self.contents.dispose
    self.contents = Bitmap.new(width - 32,
      [WLH * $game_party.members.size, height - 32].max)
  end
  #--------------------------------------------------------------------------
  # â—� リフレッシュ
  #--------------------------------------------------------------------------
  alias refresh_KGC_LargeParty refresh
  def refresh
    create_contents

    refresh_KGC_LargeParty
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆ï
¿½
��
��☆★☆★☆★☆★☆★☆★

#==============================================================================
# â–¡ Window_PartyFormCaption
#------------------------------------------------------------------------------
# 　パーティ編æˆ�ç”»é�¢ã�§ã‚¦ã‚£ãƒ³ãƒ‰ã‚¦ã�®ã‚­ãƒ£ãƒ—ションを表示ã�™ï¿
½
�
�ウィンドウ��。
#==============================================================================

class Window_PartyFormCaption < Window_Base
  #--------------------------------------------------------------------------
  # â—� オブジェクトåˆ�期化
  #     caption : 表示ã�™ã‚‹ã‚­ãƒ£ãƒ—ション
  #--------------------------------------------------------------------------
  def initialize(caption = "")
    super(0, 0, KGC::LargeParty::CAPTION_WINDOW_WIDTH, WLH + 32)
    @caption = caption
    refresh
  end
  #--------------------------------------------------------------------------
  # â—� リフレッシュ
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    self.contents.draw_text(0, 0, width - 32, WLH, @caption)
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆ï
¿½
��
��☆★☆★☆★☆★☆★☆★

#==============================================================================
# â–¡ Window_PartyFormMember
#------------------------------------------------------------------------------
# 　パーティ編æˆ�ç”»é�¢ã�§ãƒ¡ãƒ³ãƒ�ーを表示ã�™ã‚‹ã‚¦ã‚£ãƒ³ãƒ‰ã‚¦ã�§ã�™ï¿
½
�
�
#==============================================================================

class Window_PartyFormMember < Window_Selectable
  #--------------------------------------------------------------------------
  # â—‹ 定数
  #--------------------------------------------------------------------------
  DRAW_SIZE = KGC::LargeParty::PARTY_FORM_CHARACTER_SIZE
  #--------------------------------------------------------------------------
  # â—� 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_accessor :selected_index           # é�¸æŠžæ¸ˆã�¿ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹
  #--------------------------------------------------------------------------
  # â—� オブジェクトåˆ�期化
  #     x       : ウィンドウã�® X 座標
  #     y       : ウィンドウã�® Y 座標
  #     width   : ウィンドウã�®å¹…
  #     height  : ウィンドウã�®é«˜ã�•
  #     spacing : 横ã�«é …ç›®ã�Œä¸¦ã�¶ã�¨ã��ã�®ç©ºç™½ã�®å¹…
  #--------------------------------------------------------------------------
  def initialize(x, y, width, height, spacing = 8)
    super(x, y, width, height, spacing)
  end
  #--------------------------------------------------------------------------
  # â—� ウィンドウ内容ã�®ä½œæˆ�
  #--------------------------------------------------------------------------
  def create_contents
    self.contents.dispose
    self.contents = Bitmap.new(width - 32,
      [height - 32, row_max * DRAW_SIZE[1]].max)
  end
  #--------------------------------------------------------------------------
  # â—� 先頭ã�®è¡Œã�®å�–å¾—
  #--------------------------------------------------------------------------
  def top_row
    return self.oy / DRAW_SIZE[1]
  end
  #--------------------------------------------------------------------------
  # â—� 先頭ã�®è¡Œã�®è¨­å®š
  #     row : 先頭ã�«è¡¨ç¤ºã�™ã‚‹è¡Œ
  #--------------------------------------------------------------------------
  def top_row=(row)
    super(row)
    self.oy = self.oy / WLH * DRAW_SIZE[1]
  end
  #--------------------------------------------------------------------------
  # â—� 1 ページã�«è¡¨ç¤ºã�§ã��る行数ã�®å�–å¾—
  #--------------------------------------------------------------------------
  def page_row_max
    return (self.height - 32) / DRAW_SIZE[1]
  end
  #--------------------------------------------------------------------------
  # â—� 項目をæ��ç”»ã�™ã‚‹çŸ©å½¢ã�®å�–å¾—
  #     index : 項目番å�·
  #--------------------------------------------------------------------------
  def item_rect(index)
    rect = super(index)
    rect.width = DRAW_SIZE[0]
    rect.height = DRAW_SIZE[1]
    rect.y = index / @column_max * DRAW_SIZE[1]
    return rect
  end
  #--------------------------------------------------------------------------
  # â—‹ é�¸æŠžã‚¢ã‚¯ã‚¿ãƒ¼å�–å¾—
  #--------------------------------------------------------------------------
  def actor
    return @actors[self.index]
  end
  #--------------------------------------------------------------------------
  # â—� リフレッシュ
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    restore_member_list
    draw_member
  end
  #--------------------------------------------------------------------------
  # â—‹ メンãƒ�ーリスト修復
  #--------------------------------------------------------------------------
  def restore_member_list
    # 継承先ã�§å®šç¾©
  end
  #--------------------------------------------------------------------------
  # â—‹ メンãƒ�ーæ��ç”»
  #--------------------------------------------------------------------------
  def draw_member
    # 継承先ã�§å®šç¾©
  end
  #--------------------------------------------------------------------------
  # â—‹ 空欄アクターæ��ç”»
  #     index : 項目番å�·
  #--------------------------------------------------------------------------
  def draw_empty_actor(index)
    # 継承先ã�§å®šç¾©
  end
  #--------------------------------------------------------------------------
  # â—‹ 固定キャラ背景æ��ç”»
  #     index : 項目番å�·
  #--------------------------------------------------------------------------
  def draw_fixed_back(index)
    rect = item_rect(index)
    self.contents.fill_rect(rect, KGC::LargeParty::FIXED_COLOR)
  end
  #--------------------------------------------------------------------------
  # â—‹ é�¸æŠžä¸­ã‚­ãƒ£ãƒ©èƒŒæ™¯æ��ç”»
  #     index : 項目番å�·
  #--------------------------------------------------------------------------
  def draw_selected_back(index)
    rect = item_rect(index)
    self.contents.fill_rect(rect, KGC::LargeParty::SELECTED_COLOR)
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆ï
¿½
��
��☆★☆★☆★☆★☆★☆★

#==============================================================================
# â–¡ Window_PartyFormBattleMember
#------------------------------------------------------------------------------
# 　パーティ編æˆ�ç”»é�¢ã�§æˆ¦é—˜ãƒ¡ãƒ³ãƒ�ーを表示ã�™ã‚‹ã‚¦ã‚£ãƒ³ãƒ‰ã‚¦ï¿
½
�
��。
#==============================================================================

class Window_PartyFormBattleMember < Window_PartyFormMember
  #--------------------------------------------------------------------------
  # â—� 公開インスタンス変数
  #--------------------------------------------------------------------------
  attr_accessor :selected_index           # é�¸æŠžæ¸ˆã�¿ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹
  #--------------------------------------------------------------------------
  # â—� オブジェクトåˆ�期化
  #--------------------------------------------------------------------------
  def initialize
    super(0, 0, 64, DRAW_SIZE[1] + 32)
    column_width = DRAW_SIZE[0] + @spacing
    nw = [column_width * $game_party.max_battle_member_count + 32,
      Graphics.width].min
    self.width = nw

    @item_max = $game_party.max_battle_member_count
    @column_max = width / column_width
    @selected_index = nil
    create_contents
    refresh
    self.active = true
    self.index = 0
  end
  #--------------------------------------------------------------------------
  # â—‹ メンãƒ�ーリスト修復
  #--------------------------------------------------------------------------
  def restore_member_list
    @actors = $game_party.battle_members
  end
  #--------------------------------------------------------------------------
  # â—‹ メンãƒ�ーæ��ç”»
  #--------------------------------------------------------------------------
  def draw_member
    @item_max.times { |i|
      actor = @actors[i]
      if actor == nil
        draw_empty_actor(i)
      else
        if i == @selected_index
          draw_selected_back(i)
        elsif $game_party.actor_fixed?(actor.id)
          draw_fixed_back(i)
        end
        rect = item_rect(i)
        draw_actor_graphic(actor,
          rect.x + DRAW_SIZE[0] / 2,
          rect.y + DRAW_SIZE[1] - 4)
      end
    }
  end
  #--------------------------------------------------------------------------
  # â—‹ 空欄アクターæ��ç”»
  #     index : 項目番å�·
  #--------------------------------------------------------------------------
  def draw_empty_actor(index)
    rect = item_rect(index)
    self.contents.font.color = system_color
    self.contents.draw_text(rect, KGC::LargeParty::BATTLE_MEMBER_BLANK_TEXT, 1)
    self.contents.font.color = normal_color
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆ï
¿½
��
��☆★☆★☆★☆★☆★☆★

#==============================================================================
# â–¡ Window_PartyFormAllMember
#------------------------------------------------------------------------------
# 　パーティ編æˆ�ç”»é�¢ã�§å…¨ãƒ¡ãƒ³ãƒ�ーを表示ã�™ã‚‹ã‚¦ã‚£ãƒ³ãƒ‰ã‚¦ã�§ï¿
½
�
�。
#==============================================================================

class Window_PartyFormAllMember < Window_PartyFormMember
  #--------------------------------------------------------------------------
  # â—� オブジェクトåˆ�期化
  #--------------------------------------------------------------------------
  def initialize
    super(0, 0, 64, 64)
    restore_member_list
    @item_max = $game_party.all_members.size

    # å�„種サイズ計算
    column_width = DRAW_SIZE[0] + @spacing
    sw = [@item_max * column_width + 32, Graphics.width].min
    @column_max = (sw - 32) / column_width
    sh = ([@item_max - 1, 0].max / @column_max + 1) * DRAW_SIZE[1] + 32
    sh = [sh, DRAW_SIZE[1] * KGC::LargeParty::PARTY_MEMBER_WINDOW_ROW_MAX + 32].min

    # 座標・サイズ調整
    self.y += DRAW_SIZE[1] + 32
    self.width = sw
    self.height = sh

    create_contents
    refresh
    self.active = false
    self.index = 0
  end
  #--------------------------------------------------------------------------
  # â—‹ é�¸æŠžã�—ã�¦ã�„るアクターã�®ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹å�–å¾—
  #--------------------------------------------------------------------------
  def actor_index
    return @index_offset + self.index
  end
  #--------------------------------------------------------------------------
  # â—‹ メンãƒ�ーリスト修復
  #--------------------------------------------------------------------------
  def restore_member_list
    if KGC::LargeParty::SHOW_BATTLE_MEMBER_IN_PARTY
      @actors = $game_party.all_members
      @index_offset = 0
    else
      @actors = $game_party.stand_by_members
      @index_offset = $game_party.battle_members.size
    end
  end
  #--------------------------------------------------------------------------
  # â—‹ メンãƒ�ーæ��ç”»
  #--------------------------------------------------------------------------
  def draw_member
    @item_max.times { |i|
      actor = @actors[i]
      if actor == nil
        draw_empty_actor(i)
        next
      end

      if $game_party.actor_fixed?(actor.id)
        draw_fixed_back(i)
      end
      rect = item_rect(i)
      opacity = ($game_party.battle_members.include?(actor) ? 96 : 255)
      draw_actor_graphic(actor,
        rect.x + DRAW_SIZE[0] / 2,
        rect.y + DRAW_SIZE[1] - 4,
        opacity)
    }
  end
  #--------------------------------------------------------------------------
  # â—� アクターã�®æ­©è¡Œã‚°ãƒ©ãƒ•ã‚£ãƒƒã‚¯æ��ç”»
  #     actor   : アクター
  #     x       : æ��画先 X 座標
  #     y       : æ��画先 Y 座標
  #     opacity : ä¸�é€�明度
  #--------------------------------------------------------------------------
  def draw_actor_graphic(actor, x, y, opacity = 255)
    draw_character(actor.character_name, actor.character_index, x, y, opacity)
  end
  #--------------------------------------------------------------------------
  # â—� 歩行グラフィックã�®æ��ç”»
  #     character_name  : 歩行グラフィック ファイルå��
  #     character_index : 歩行グラフィック インデックス
  #     x               : æ��画先 X 座標
  #     y               : æ��画先 Y 座標
  #     opacity         : ä¸�é€�明度
  #--------------------------------------------------------------------------
  def draw_character(character_name, character_index, x, y, opacity = 255)
    return if character_name == nil
    bitmap = Cache.character(character_name)
    sign = character_name[/^[\!\$]./]
    if sign != nil and sign.include?('$')
      cw = bitmap.width / 3
      ch = bitmap.height / 4
    else
      cw = bitmap.width / 12
      ch = bitmap.height / 8
    end
    n = character_index
    src_rect = Rect.new((n%4*3+1)*cw, (n/4*4)*ch, cw, ch)
    self.contents.blt(x - cw / 2, y - ch, bitmap, src_rect, opacity)
  end
  #--------------------------------------------------------------------------
  # â—‹ 空欄アクターæ��ç”»
  #     index : 項目番å�·
  #--------------------------------------------------------------------------
  def draw_empty_actor(index)
    rect = item_rect(index)
    self.contents.font.color = system_color
    self.contents.draw_text(rect, KGC::LargeParty::PARTY_MEMBER_BLANK_TEXT, 1)
    self.contents.font.color = normal_color
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆ï
¿½
��
��☆★☆★☆★☆★☆★☆★

#==============================================================================
# â–¡ Window_PartyFormStatus
#------------------------------------------------------------------------------
# 　パーティ編æˆ�ç”»é�¢ã�§ã‚¢ã‚¯ã‚¿ãƒ¼ã�®ã‚¹ãƒ†ãƒ¼ã‚¿ã‚¹ã‚’表示ã�™ã‚‹ã‚¦ï¿
½
�
�ンドウ��。
#==============================================================================

class Window_PartyFormStatus < Window_Base
  #--------------------------------------------------------------------------
  # â—� オブジェクトåˆ�期化
  #--------------------------------------------------------------------------
  def initialize
    super(0, 0, 384, 128)
    self.z = 1000
    @actor = nil
    refresh
  end
  #--------------------------------------------------------------------------
  # â—‹ アクター設定
  #--------------------------------------------------------------------------
  def set_actor(actor)
    if @actor != actor
      @actor = actor
      refresh
    end
  end
  #--------------------------------------------------------------------------
  # â—� リフレッシュ
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    if @actor == nil
      return
    end

    draw_actor_face(@actor, 0, 0)
    dx = 104
    draw_actor_name(@actor, dx, 0)
    draw_actor_level(@actor, dx, WLH * 1)
    draw_actor_hp(@actor, dx, WLH * 2)
    draw_actor_mp(@actor, dx, WLH * 3)
    4.times { |i|
      draw_actor_parameter(@actor, dx + 128, WLH * i, i, 120)
    }
  end
  #--------------------------------------------------------------------------
  # â—� 能力値ã�®æ��ç”»
  #     actor : アクター
  #     x     : æ��画先 X 座標
  #     y     : æ��画先 Y 座標
  #     type  : 能力値ã�®ç¨®é¡ž (0～3)
  #     width : æ��画幅
  #--------------------------------------------------------------------------
  def draw_actor_parameter(actor, x, y, type, width = 156)
    case type
    when 0
      parameter_name = Vocab::atk
      parameter_value = actor.atk
    when 1
      parameter_name = Vocab::def
      parameter_value = actor.def
    when 2
      parameter_name = Vocab::spi
      parameter_value = actor.spi
    when 3
      parameter_name = Vocab::agi
      parameter_value = actor.agi
    end
    nw = width - 36
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, nw, WLH, parameter_name)
    self.contents.font.color = normal_color
    self.contents.draw_text(x + nw, y, 36, WLH, parameter_value, 2)
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆ï
¿½
��
��☆★☆★☆★☆★☆★☆★

#==============================================================================
# â–¡ Window_PartyFormControl
#------------------------------------------------------------------------------
# 　パーティ編æˆ�ç”»é�¢ã�§æ“�作方法を表示ã�™ã‚‹ã‚¦ã‚£ãƒ³ãƒ‰ã‚¦ã�§ã�™ï¿
½
�
�
#==============================================================================

class Window_PartyFormControl < Window_Base
  #--------------------------------------------------------------------------
  # â—‹ 定数
  #--------------------------------------------------------------------------
  MODE_BATTLE_MEMBER = 0
  MODE_SHIFT_CHANGE  = 1
  MODE_PARTY_MEMBER  = 2
  #--------------------------------------------------------------------------
  # â—� オブジェクトåˆ�期化
  #--------------------------------------------------------------------------
  def initialize
    super(0, 0, Graphics.width - 384, 128)
    self.z = 1000
    @mode = MODE_BATTLE_MEMBER
    refresh
  end
  #--------------------------------------------------------------------------
  # â—‹ モード変更
  #--------------------------------------------------------------------------
  def mode=(value)
    @mode = value
    refresh
  end
  #--------------------------------------------------------------------------
  # â—� リフレッシュ
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    case @mode
    when MODE_BATTLE_MEMBER  # 戦闘メンãƒ�ー
      buttons = [
        "A: Remove",
        "B: End",
        "C: Confirm",
        "X: Sort"
      ]
    when MODE_SHIFT_CHANGE   # 並ã�³æ›¿ã�ˆ
      buttons = [
        "B: Cancel",
        "C: Confirm",
        "X: Confirm"
      ]
    when MODE_PARTY_MEMBER   # パーティメンãƒ�ー
      buttons = [
        "B: Cancel",
        "C: Confirm"
      ]
    else
      return
    end

    buttons.each_with_index { |c, i|
      self.contents.draw_text(0, WLH * i, width - 32, WLH, c)
    }
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆ï
¿½
��
��☆★☆★☆★☆★☆★☆★

#==============================================================================
# â–  Scene_Title
#==============================================================================

class Scene_Title < Scene_Base
  #--------------------------------------------------------------------------
  # â—� å�„種ゲームオブジェクトã�®ä½œæˆ�
  #--------------------------------------------------------------------------
  alias create_game_objects_KGC_LargeParty create_game_objects
  def create_game_objects
    create_game_objects_KGC_LargeParty

    if KGC::LargeParty::DEFAULT_PARTYFORM_ENABLED
      $game_switches[KGC::LargeParty::PARTYFORM_SWITCH] = true
      $game_switches[KGC::LargeParty::BATTLE_PARTYFORM_SWITCH] = true
    end
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆ï
¿½
��
��☆★☆★☆★☆★☆★☆★

#==============================================================================
# â–  Scene_Map
#==============================================================================

class Scene_Map < Scene_Base
  #--------------------------------------------------------------------------
  # â—� ç”»é�¢åˆ‡ã‚Šæ›¿ã�ˆã�®å®Ÿè¡Œ
  #--------------------------------------------------------------------------
  alias update_scene_change_KGC_LargeParty update_scene_change
  def update_scene_change
    return if $game_player.moving?    # プレイヤーã�®ç§»å‹•ä¸­ï¼Ÿ

    if $game_temp.next_scene == :partyform
      call_partyform
      return
    end

    update_scene_change_KGC_LargeParty
  end
  #--------------------------------------------------------------------------
  # â—‹ パーティ編æˆ�ç”»é�¢ã�¸ã�®åˆ‡ã‚Šæ›¿ã�ˆ
  #--------------------------------------------------------------------------
  def call_partyform
    $game_temp.next_scene = nil
    $scene = Scene_PartyForm.new(0, Scene_PartyForm::HOST_MAP)
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆ï
¿½
��
��☆★☆★☆★☆★☆★☆★

#==============================================================================
# â–  Scene_Menu
#==============================================================================

class Scene_Menu < Scene_Base
  if KGC::LargeParty::USE_MENU_PARTYFORM_COMMAND
  #--------------------------------------------------------------------------
  # â—� コマンドウィンドウã�®ä½œæˆ�
  #--------------------------------------------------------------------------
  alias create_command_window_KGC_LargeParty create_command_window
  def create_command_window
    create_command_window_KGC_LargeParty

    return if $imported["CustomMenuCommand"]

    @__command_partyform_index =
      @command_window.add_command(Vocab.partyform)
    @command_window.draw_item(@__command_partyform_index,
      $game_party.partyform_enable?)
    if @command_window.oy > 0
      @command_window.oy -= Window_Base::WLH
    end
    @command_window.index = @menu_index
  end
  end
  #--------------------------------------------------------------------------
  # â—� コマンドé�¸æŠžã�®æ›´æ–°
  #--------------------------------------------------------------------------
  alias update_command_selection_KGC_LargeParty update_command_selection
  def update_command_selection
    current_menu_index = @__command_partyform_index
    call_partyform_flag = false

    if Input.trigger?(Input::C)
      case @command_window.index
      when @__command_partyform_index  # パーティ編æˆ�
        call_partyform_flag = true
      end
    # パーティ編æˆ�ボタン押下
    elsif KGC::LargeParty::MENU_PARTYFORM_BUTTON != nil &&
        Input.trigger?(KGC::LargeParty::MENU_PARTYFORM_BUTTON)
      call_partyform_flag = true
      current_menu_index = @command_window.index if current_menu_index == nil
    end

    # パーティ編æˆ�ç”»é�¢ã�«ç§»è¡Œ
    if call_partyform_flag
      if $game_party.members.size == 0 || !$game_party.partyform_enable?
        Sound.play_buzzer
        return
      end
      Sound.play_decision
      $scene = Scene_PartyForm.new(current_menu_index)
      return
    end

    update_command_selection_KGC_LargeParty
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆ï
¿½
��
��☆★☆★☆★☆★☆★☆★

#==============================================================================
# â–  Scene_Shop
#==============================================================================

unless $imported["HelpExtension"]
class Scene_Shop < Scene_Base
  #--------------------------------------------------------------------------
  # â—� フレーム更新
  #--------------------------------------------------------------------------
  alias udpate_KGC_LargeParty update
  def update
    # スクロール判定
    if !@command_window.active &&
        KGC::LargeParty::SHOP_STATUS_SCROLL_BUTTON != nil &&
        Input.press?(KGC::LargeParty::SHOP_STATUS_SCROLL_BUTTON)
      super
      update_menu_background
      update_scroll_status
      return
    else
      @status_window.cursor_rect.empty
    end

    udpate_KGC_LargeParty
  end
  #--------------------------------------------------------------------------
  # â—‹ ステータスウィンドウã�®ã‚¹ã‚¯ãƒ­ãƒ¼ãƒ«å‡¦ç�†
  #--------------------------------------------------------------------------
  def update_scroll_status
    # ステータスウィンドウã�«ã‚«ãƒ¼ã‚½ãƒ«ã‚’表示
    @status_window.cursor_rect.width = @status_window.contents.width
    @status_window.cursor_rect.height = @status_window.height - 32
    @status_window.update

    if Input.press?(Input::UP)
      @status_window.oy = [@status_window.oy - 4, 0].max
    elsif Input.press?(Input::DOWN)
      max_pos = [@status_window.contents.height -
        (@status_window.height - 32), 0].max
      @status_window.oy = [@status_window.oy + 4, max_pos].min
    end
  end
end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆ï
¿½
��
��☆★☆★☆★☆★☆★☆★

#==============================================================================
# â–¡ Scene_PartyForm
#------------------------------------------------------------------------------
# 　パーティ編�画��処�を行�クラス��。
#==============================================================================

class Scene_PartyForm < Scene_Base
  #--------------------------------------------------------------------------
  # â—‹ 定数
  #--------------------------------------------------------------------------
  CAPTION_OFFSET = 40  # キャプションウィンドウã�®ä½�置補正
  HOST_MENU   = 0      # 呼ã�³å‡ºã�—å…ƒ : メニュー
  HOST_MAP    = 1      # 呼ã�³å‡ºã�—å…ƒ : マップ
  HOST_BATTLE = 2      # 呼ã�³å‡ºã�—å…ƒ : 戦闘
  #--------------------------------------------------------------------------
  # â—� オブジェクトåˆ�期化
  #     menu_index : コマンドã�®ã‚«ãƒ¼ã‚½ãƒ«åˆ�期ä½�ç½®
  #     host_scene : 呼ã�³å‡ºã�—å…ƒ (0..メニュー  1..マップ  2..戦闘)
  #--------------------------------------------------------------------------
  def initialize(menu_index = 0, host_scene = HOST_MENU)
    @menu_index = menu_index
    @host_scene = host_scene
  end
  #--------------------------------------------------------------------------
  # â—� 開始処ç�†
  #--------------------------------------------------------------------------
  def start
    super
    create_menu_background

    create_windows
    create_confirm_window
    adjust_window_location

    # ç·¨æˆ�å‰�ã�®ãƒ‘ーティをä¿�å­˜
    @battle_actors = $game_party.battle_members.dup
    @party_actors  = $game_party.all_members.dup
  end
  #--------------------------------------------------------------------------
  # â—‹ ウィンドウã�®ä½œæˆ�
  #--------------------------------------------------------------------------
  def create_windows
    # ç·¨æˆ�用ウィンドウを作æˆ�
    @battle_member_window = Window_PartyFormBattleMember.new
    @party_member_window  = Window_PartyFormAllMember.new
    @status_window        = Window_PartyFormStatus.new
    @status_window.set_actor(@battle_member_window.actor)

    # ã��ã�®ä»–ã�®ã‚¦ã‚£ãƒ³ãƒ‰ã‚¦ã‚’作æˆ�
    @battle_member_caption_window =
      Window_PartyFormCaption.new(KGC::LargeParty::BATTLE_MEMBER_CAPTION)
    @party_member_caption_window =
      Window_PartyFormCaption.new(KGC::LargeParty::PARTY_MEMBER_CAPTION)
    @control_window = Window_PartyFormControl.new
  end
  #--------------------------------------------------------------------------
  # â—‹ 確èª�ウィンドウã�®ä½œæˆ�
  #--------------------------------------------------------------------------
  def create_confirm_window
    commands = KGC::LargeParty::CONFIRM_WINDOW_COMMANDS
    @confirm_window =
      Window_Command.new(KGC::LargeParty::CONFIRM_WINDOW_WIDTH, commands)
    @confirm_window.index    = 0
    @confirm_window.openness = 0
    @confirm_window.active   = false
  end
  #--------------------------------------------------------------------------
  # â—‹ ウィンドウã�®åº§æ¨™èª¿æ•´
  #--------------------------------------------------------------------------
  def adjust_window_location
    # 基準座標を計算
    base_x = [@battle_member_window.width, @party_member_window.width].max
    base_x = [(Graphics.width - base_x) / 2, 0].max
    base_y = @battle_member_window.height + @party_member_window.height +
      @status_window.height + CAPTION_OFFSET * 2
    base_y = [(Graphics.height - base_y) / 2, 0].max
    base_z = @menuback_sprite.z + 1000

    # ç·¨æˆ�用ウィンドウã�®åº§æ¨™ã‚’セット
    @battle_member_window.x = base_x
    @battle_member_window.y = base_y + CAPTION_OFFSET
    @battle_member_window.z = base_z
    @party_member_window.x = base_x
    @party_member_window.y = @battle_member_window.y +
      @battle_member_window.height + CAPTION_OFFSET
    @party_member_window.z = base_z
    @status_window.x = 0
    @status_window.y = @party_member_window.y + @party_member_window.height
    @status_window.z = base_z

    # ã��ã�®ä»–ã�®ã‚¦ã‚£ãƒ³ãƒ‰ã‚¦ã�®åº§æ¨™ã‚’セット
    @battle_member_caption_window.x = [base_x - 16, 0].max
    @battle_member_caption_window.y = @battle_member_window.y - CAPTION_OFFSET
    @battle_member_caption_window.z = base_z + 500
    @party_member_caption_window.x = [base_x - 16, 0].max
    @party_member_caption_window.y = @party_member_window.y - CAPTION_OFFSET
    @party_member_caption_window.z = base_z + 500
    @control_window.x = @status_window.width
    @control_window.y = @status_window.y
    @control_window.z = base_z

    @confirm_window.x = (Graphics.width - @confirm_window.width) / 2
    @confirm_window.y = (Graphics.height - @confirm_window.height) / 2
    @confirm_window.z = base_z + 1000
  end
  #--------------------------------------------------------------------------
  # â—� 終了処ç�†
  #--------------------------------------------------------------------------
  def terminate
    super
    dispose_menu_background
    @battle_member_window.dispose
    @party_member_window.dispose
    @status_window.dispose
    @battle_member_caption_window.dispose
    @party_member_caption_window.dispose
    @control_window.dispose
    @confirm_window.dispose
  end
  #--------------------------------------------------------------------------
  # â—� メニュー画é�¢ç³»ã�®èƒŒæ™¯ä½œæˆ�
  #--------------------------------------------------------------------------
  def create_menu_background
    super
    @menuback_sprite.z = 20000
  end
  #--------------------------------------------------------------------------
  # â—� å…ƒã�®ç”»é�¢ã�¸æˆ»ã‚‹
  #--------------------------------------------------------------------------
  def return_scene
    case @host_scene
    when HOST_MENU
      $scene = Scene_Menu.new(@menu_index)
    when HOST_MAP
      $scene = Scene_Map.new
    when HOST_BATTLE
      $scene = Scene_Battle.new
    end
    $game_player.refresh
  end
  #--------------------------------------------------------------------------
  # â—� フレーム更新
  #--------------------------------------------------------------------------
  def update
    super
    update_menu_background
    update_window
    if @battle_member_window.active
      update_battle_member
    elsif @party_member_window.active
      update_party_member
    elsif @confirm_window.active
      update_confirm
    end
  end
  #--------------------------------------------------------------------------
  # â—‹ ウィンドウ更新
  #--------------------------------------------------------------------------
  def update_window
    @battle_member_window.update
    @party_member_window.update
    @status_window.update
    @battle_member_caption_window.update
    @party_member_caption_window.update
    @control_window.update
    @confirm_window.update
  end
  #--------------------------------------------------------------------------
  # â—‹ ウィンドウå†�æ��ç”»
  #--------------------------------------------------------------------------
  def refresh_window
    @battle_member_window.refresh
    @party_member_window.refresh
  end
  #--------------------------------------------------------------------------
  # â—‹ フレーム更新 (戦闘メンãƒ�ーウィンドウã�Œã‚¢ã‚¯ãƒ†ã‚£ãƒ–ã�®å ´å�ˆ)
  #--------------------------------------------------------------------------
  def update_battle_member
    @status_window.set_actor(@battle_member_window.actor)
    if Input.trigger?(Input::A)
      if @battle_member_window.selected_index == nil  # 並ã�³æ›¿ã�ˆä¸­ã�§ã�ªã�„
        actor = @battle_member_window.actor
        # アクターを外ã�›ã�ªã�„å ´å�ˆ
        if actor == nil || $game_party.actor_fixed?(actor.id)
          Sound.play_buzzer
          return
        end
        # アクターを外ã�™
        Sound.play_decision
        actors = $game_party.battle_members
        actors.delete_at(@battle_member_window.index)
        $game_party.set_battle_member(actors)
        refresh_window
      end
    elsif Input.trigger?(Input::B)
      if @battle_member_window.selected_index == nil  # 並ã�³æ›¿ã�ˆä¸­ã�§ã�ªã�„
        # 確èª�ウィンドウã�«åˆ‡ã‚Šæ›¿ã�ˆ
        Sound.play_cancel
        show_confirm_window
      else                                            # 並ã�³æ›¿ã�ˆä¸­
        # 並ã�³æ›¿ã�ˆè§£é™¤
        Sound.play_cancel
        @battle_member_window.selected_index = nil
        @battle_member_window.refresh
        @control_window.mode = Window_PartyFormControl::MODE_BATTLE_MEMBER
      end
    elsif Input.trigger?(Input::C)
      if @battle_member_window.selected_index == nil  # 並ã�³æ›¿ã�ˆä¸­ã�§ã�ªã�„
        actor = @battle_member_window.actor
        # アクターを外ã�›ã�ªã�„å ´å�ˆ
        if actor != nil && $game_party.actor_fixed?(actor.id)
          Sound.play_buzzer
          return
        end
        # パーティメンãƒ�ーウィンドウã�«åˆ‡ã‚Šæ›¿ã�ˆ
        Sound.play_decision
        @battle_member_window.active = false
        @party_member_window.active = true
        @control_window.mode = Window_PartyFormControl::MODE_PARTY_MEMBER
      else                                            # 並ã�³æ›¿ã�ˆä¸­
        unless can_change_shift?(@battle_member_window.actor)
          Sound.play_buzzer
          return
        end
        # 並ã�³æ›¿ã�ˆå®Ÿè¡Œ
        Sound.play_decision
        index1 = @battle_member_window.selected_index
        index2 = @battle_member_window.index
        change_shift(index1, index2)
        @control_window.mode = Window_PartyFormControl::MODE_BATTLE_MEMBER
      end
    elsif Input.trigger?(Input::X)
      # 並ã�³æ›¿ã�ˆä¸�å�¯èƒ½ã�ªå ´å�ˆ
      unless can_change_shift?(@battle_member_window.actor)
        Sound.play_buzzer
        return
      end
      if @battle_member_window.selected_index == nil  # 並ã�³æ›¿ã�ˆä¸­ã�§ã�ªã�„
        # 並ã�³æ›¿ã�ˆé–‹å§‹
        Sound.play_decision
        @battle_member_window.selected_index = @battle_member_window.index
        @battle_member_window.refresh
        @control_window.mode = Window_PartyFormControl::MODE_SHIFT_CHANGE
      else                                            # 並ã�³æ›¿ã�ˆä¸­
        # 並ã�³æ›¿ã�ˆå®Ÿè¡Œ
        Sound.play_decision
        index1 = @battle_member_window.selected_index
        index2 = @battle_member_window.index
        change_shift(index1, index2)
        @control_window.mode = Window_PartyFormControl::MODE_BATTLE_MEMBER
      end
    end
  end
  #--------------------------------------------------------------------------
  # â—‹ 並ã�³æ›¿ã�ˆå�¯å�¦åˆ¤å®š
  #--------------------------------------------------------------------------
  def can_change_shift?(actor)
    # é�¸æŠžã�—ã�Ÿã‚¢ã‚¯ã‚¿ãƒ¼ã�Œå­˜åœ¨ã�—ã�ªã�„ã€�ã�¾ã�Ÿã�¯ä¸¦ã�³æ›¿ã�ˆä¸�能ã�ªå ´ï¿
½
�
�
    if actor == nil ||
        (KGC::LargeParty::FORBID_CHANGE_SHIFT_FIXED &&
         $game_party.actor_fixed?(actor.id))
      return false
    end
    return true
  end
  #--------------------------------------------------------------------------
  # â—‹ 並ã�³æ›¿ã�ˆ
  #--------------------------------------------------------------------------
  def change_shift(index1, index2)
    # ä½�置を入れ替ã�ˆ
    $game_party.change_shift(index1, index2)
    # é�¸æŠžæ¸ˆã�¿ã‚¤ãƒ³ãƒ‡ãƒƒã‚¯ã‚¹ã‚’クリア
    @battle_member_window.selected_index = nil
    refresh_window
  end
  #--------------------------------------------------------------------------
  # â—‹ フレーム更新 (パーティウィンドウã�Œã‚¢ã‚¯ãƒ†ã‚£ãƒ–ã�®å ´å�ˆ)
  #--------------------------------------------------------------------------
  def update_party_member
    @status_window.set_actor(@party_member_window.actor)
    if Input.trigger?(Input::B)
      Sound.play_cancel
      # 戦闘メンãƒ�ーウィンドウã�«åˆ‡ã‚Šæ›¿ã�ˆ
      @battle_member_window.active = true
      @party_member_window.active = false
        @control_window.mode = Window_PartyFormControl::MODE_BATTLE_MEMBER
    elsif Input.trigger?(Input::C)
      actor = @party_member_window.actor
      # アクターã�Œæˆ¦é—˜ãƒ¡ãƒ³ãƒ�ーã�«å�«ã�¾ã‚Œã‚‹å ´å�ˆ
      if $game_party.battle_members.include?(actor)
        Sound.play_buzzer
        return
      end
      # アクターを入れ替ã�ˆ
      Sound.play_decision
      actors = $game_party.all_members
      battle_actors = $game_party.battle_members
      if @battle_member_window.actor != nil
        actors[@party_member_window.actor_index] = @battle_member_window.actor
        actors[@battle_member_window.index] = actor
        $game_party.set_member(actors.compact)
      end
      battle_actors[@battle_member_window.index] = actor
      $game_party.set_battle_member(battle_actors.compact)
      refresh_window
      # 戦闘メンãƒ�ーウィンドウã�«åˆ‡ã‚Šæ›¿ã�ˆ
      @battle_member_window.active = true
      @party_member_window.active = false
      @control_window.mode = Window_PartyFormControl::MODE_BATTLE_MEMBER
    end
  end
  #--------------------------------------------------------------------------
  # â—‹ フレーム更新 (確èª�ウィンドウã�Œã‚¢ã‚¯ãƒ†ã‚£ãƒ–ã�®å ´å�ˆ)
  #--------------------------------------------------------------------------
  def update_confirm
    if Input.trigger?(Input::B)
      Sound.play_cancel
      hide_confirm_window
    elsif Input.trigger?(Input::C)
      case @confirm_window.index
      when 0  # ç·¨æˆ�完了
        # パーティã�Œç„¡åŠ¹ã�®å ´å�ˆ
        unless battle_member_valid?
          Sound.play_buzzer
          return
        end
        Sound.play_decision
        return_scene
      when 1  # ç·¨æˆ�中断
        Sound.play_decision
        # パーティを編æˆ�å‰�ã�®çŠ¶æ…‹ã�«æˆ»ã�™
        $game_party.set_member(@party_actors)
        $game_party.set_battle_member(@battle_actors)
        return_scene
      when 2  # キャンセル
        Sound.play_cancel
        hide_confirm_window
      end
    end
  end
  #--------------------------------------------------------------------------
  # â—‹ 戦闘メンãƒ�ー有効判定
  #--------------------------------------------------------------------------
  def battle_member_valid?
    return false if $game_party.battle_members.size == 0  # 戦闘メンãƒ�ーã�Œç©º
    $game_party.battle_members.each { |actor|
      return true if actor.exist?  # 生存者ã�Œã�„ã‚Œã�°OK
    }
    return false
  end
  #--------------------------------------------------------------------------
  # â—‹ 確èª�ウィンドウã�®è¡¨ç¤º
  #--------------------------------------------------------------------------
  def show_confirm_window
    if @battle_member_window.active
      @last_active_window = @battle_member_window
    else
      @last_active_window = @party_member_window
    end
    @battle_member_window.active = false
    @party_member_window.active = false

    @confirm_window.draw_item(0, battle_member_valid?)
    @confirm_window.open
    @confirm_window.active = true
  end
  #--------------------------------------------------------------------------
  # â—‹ 確èª�ウィンドウã�®é�žè¡¨ç¤º
  #--------------------------------------------------------------------------
  def hide_confirm_window
    @confirm_window.active = false
    @confirm_window.close
    @last_active_window.active = true
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆ï
¿½
��
��☆★☆★☆★☆★☆★☆★

#==============================================================================
# â–  Scene_Battle
#==============================================================================

class Scene_Battle < Scene_Base
  #--------------------------------------------------------------------------
  # â—� メッセージ表示ã�Œçµ‚ã‚�ã‚‹ã�¾ã�§ã‚¦ã‚§ã‚¤ãƒˆ
  #--------------------------------------------------------------------------
  alias wait_for_message_KGC_LargeParty wait_for_message
  def wait_for_message
    return if @ignore_wait_for_message  # メッセージ終了ã�¾ã�§ã�®ã‚¦ã‚§ã‚¤ãƒˆã‚’無視

    wait_for_message_KGC_LargeParty
  end
  #--------------------------------------------------------------------------
  # â—� レベルアップã�®è¡¨ç¤º
  #--------------------------------------------------------------------------
  alias display_level_up_KGC_LargeParty display_level_up
  def display_level_up
    @ignore_wait_for_message = true

    display_level_up_KGC_LargeParty

    exp = $game_troop.exp_total * KGC::LargeParty::STAND_BY_EXP_RATE / 1000
    $game_party.stand_by_members.each { |actor|
      if actor.exist?
        actor.gain_exp(exp, KGC::LargeParty::SHOW_STAND_BY_LEVEL_UP)
      end
    }
    @ignore_wait_for_message = false
    wait_for_message
  end
  #--------------------------------------------------------------------------
  # â—� パーティコマンドé�¸æŠžã�®é–‹å§‹
  #--------------------------------------------------------------------------
  alias start_party_command_selection_KGC_LargeParty start_party_command_selection
  def start_party_command_selection
    if $game_temp.in_battle
      @status_window.index = 0
    end

    start_party_command_selection_KGC_LargeParty
  end

  if KGC::LargeParty::USE_BATTLE_PARTYFORM

  #--------------------------------------------------------------------------
  # â—� 情報表示ビューãƒ�ートã�®ä½œæˆ�
  #--------------------------------------------------------------------------
  alias create_info_viewport_KGC_LargeParty create_info_viewport
  def create_info_viewport
    create_info_viewport_KGC_LargeParty

    @__command_partyform_index =
      @party_command_window.add_command(Vocab.partyform_battle)
    @party_command_window.draw_item(@__command_partyform_index,
      $game_party.battle_partyform_enable?)
  end
  #--------------------------------------------------------------------------
  # â—� パーティコマンドé�¸æŠžã�®æ›´æ–°
  #--------------------------------------------------------------------------
  alias update_party_command_selection_KGC_LargeParty update_party_command_selection
  def update_party_command_selection
    if Input.trigger?(Input::C)
      case @party_command_window.index
      when @__command_partyform_index  # パーティ編æˆ�
        unless $game_party.battle_partyform_enable?
          Sound.play_buzzer
          return
        end
        Sound.play_decision
        process_partyform
        return
      end
    end

    update_party_command_selection_KGC_LargeParty
  end
  #--------------------------------------------------------------------------
  # â—‹ パーティ編æˆ�ã�®å‡¦ç�†
  #--------------------------------------------------------------------------
  def process_partyform
    prev_party_command_active = @party_command_window.active
    @party_command_window.active = false
    Graphics.freeze
    snapshot_for_background
    $scene = Scene_PartyForm.new(0, Scene_PartyForm::HOST_BATTLE)
    $scene.main
    $scene = self
    @spriteset.update_actors
    @status_window.refresh
    @party_command_window.active = prev_party_command_active
    Window_Base.show_cursor_animation if $imported["CursorAnimation"]
    perform_transition
  end
  #--------------------------------------------------------------------------
  # â—� 敗北ã�®å‡¦ç�†
  #--------------------------------------------------------------------------
  alias process_defeat_KGC_LargeParty process_defeat
  def process_defeat
    process_defeat_launch

    process_defeat_KGC_LargeParty if $game_party.all_dead?
  end
  #--------------------------------------------------------------------------
  # â—‹ 全滅時ã�®å…¥ã‚Œæ›¿ã�ˆå‡¦ç�†
  #--------------------------------------------------------------------------
  def process_defeat_launch
    while @spriteset.animation?
      update_basic
    end

    return unless KGC::LargeParty::ENABLE_DEFEAT_LAUNCH
    return unless $game_party.partyform_enable?

    exist = false
    $game_party.all_members.each { |actor| exist |= actor.exist? }
    return unless exist  # 生存者ã�ªã�—

    @info_viewport.visible  = false
    @message_window.visible = true

    # 戦闘å�¯èƒ½è€…を出撃 (固定アクターã�¯æ®‹ã�™)
    $game_party.remove_all_battle_member
    max = $game_party.max_battle_member_count
    while ($game_party.battle_members.size < max)
      actor = $game_party.stand_by_members.find { |a| a.exist? }
      break if actor == nil
      $game_party.add_battle_member(actor.id)
      @status_window.refresh
      display_launch(actor)
    end

    @info_viewport.visible  = true
    @message_window.visible = false
    @message_window.clear
  end
  #--------------------------------------------------------------------------
  # â—‹ 出撃ã�®è¡¨ç¤º
  #     target : 対象者 (アクター)
  #--------------------------------------------------------------------------
  def display_launch(target)
    text = sprintf(Vocab::DefeatLaunch, target.name)
    @message_window.add_instant_text(text)
    wait(40)
  end

  end  # <-- if KGC::LargeParty::USE_BATTLE_PARTYFORM
end

This post has been edited by mooshra: Jun 22 2012, 01:42 PM