Partenaires

Autres partenaires...
Devenir partenaire ?

Dernières news

- 25000 ressources
- News de Créative : Décemb...
- VX à fond !
- 6 Jeux amateurs à tester ...
- News de Créative : Octobr...
- Action Game Maker
- News de Créative : Septem...

Créations
+ de détails !

Infos

6000 ressources graphiques et audios ont été ajouté à la bibliothèque de ressources. Le site a donc atteint la barre des 25000 ressources !

Scripts RPG Maker VX

- Totalité

Nombre de scripts : 40
Derniers scripts :

Combat vus sur le coté et dynamique

Combat tactique (GTBS)

Faire une capture d'écran d'une carte

Pouvoir choisir son équipe (plus de héros)

Auteur : Inconnu

Fonction : Un menu permet de choisir son équipe en remplaçant des héros par d'autres. On peut aller sur le menu de changement d'équipe par l'intermédiaire du menu principal.

Image(s) : Image n°1

Ressource(s) : Aucune

Démo : Aucune

Remarque : Testé et fonctionnel

Nombre de scripts : 1

Installation : Ouvrez l'éditeur de script (F11). Créez en un nouveau au dessus de "Main" et collez le code ci-dessous.

Utilisation : Aucune

Code :

module KGC
   module LargeParty
     # ??????? ON/OFF ???????? ??/??? ????????
     PARTYFORM_SWITCH = 1
     # ? ?????????????????????
     # ??????????????????????????????????
     BATTLE_PARTYFORM_SWITCH = 1
     # ? ?????????????
     # true ?????????????????????????????????
     # ???? ON ??????
     DEFAULT_PARTYFORM_ENABLED = true
     
     # ? ????????? (??????)
     # 5 Nombre mximum dans les combats. (pas plus de 5)
     MAX_BATTLE_MEMBERS = 4
     # Game_Party::MAX_MEMBERS ????????
     # 100 ?????? [Window_MenuStatus] ???????
     MAX_MEMBERS = 15
     # ? ??????????????
     # ???????????????????????????
     FORBID_CHANGE_SHIFT_FIXED = false
     # ? ??????????
     # ????????? Color.new(0, 0, 0, 0)
     STAND_BY_COLOR = Color.new(0, 0, 0, 128)
     # ? ??????????
     FIXED_COLOR = Color.new(255, 128, 64, 96)
     # ? ?????????
     SELECTED_COLOR = Color.new(64, 255, 128, 128)
     # ? ????????? (???????)
     # ????????????????????????????????
     # ???????? nil
     MENU_PARTYFORM_BUTTON = Input::A
     # ? ??????????????????????
     # ???????????????????????
     # ?????????????«????????????» ?????????
     USE_MENU_PARTYFORM_COMMAND = true
     # ? ????????????????????
     VOCAB_MENU_PARTYFORM = "Equipe"
     # ? ???????????????????
     # ????????????????????(???????)???
     USE_BATTLE_PARTYFORM = true
     # ? ?????????????????
     VOCAB_BATTLE_PARTYFORM = "Ordonner"
     
     # ? ???????????????? [?, ??]
     # ???????????????????????????????
     PARTY_FORM_CHARACTER_SIZE = [40, 48]
     # ? ????????????????????????????
     BATTLE_MEMBER_BLANK_TEXT = "VIDE"
     # ? ???????????????????????
     # ???????????????????????
     # ???? 1 ????????
     PARTY_MEMBER_WINDOW_ROW_MAX = 2
     # ? ??????????????????????????????
     SHOW_BATTLE_MEMBER_IN_PARTY = false
     # ? ??????????????????????????????
     PARTY_MEMBER_BLANK_TEXT = "-"
     # ? ??????????????????
     CAPTION_WINDOW_WIDTH = 192
     # ? ???????????????????????
     BATTLE_MEMBER_CAPTION = "Equipe de combat"
     
     if SHOW_BATTLE_MEMBER_IN_PARTY
       # ? ?????????????????????????
       # SHOW_BATTLE_MEMBER_IN_PARTY = true ???
       PARTY_MEMBER_CAPTION = "Membres de l'équipe"
     else
       # ? ?????????????????????????
       # SHOW_BATTLE_MEMBER_IN_PARTY = false ???
       PARTY_MEMBER_CAPTION = "Equipe remplaçante"
     end
     
     # ? ???????????
     CONFIRM_WINDOW_WIDTH = 160
     # ? ?????????????
     # ??????·??????????????
     CONFIRM_WINDOW_COMMANDS = ["Confirmer", "Annuler", "Retour"]
     
     # ? ???????????????????????????????
     # ?????????????????????????????
     # ?????????????? nil ????
     # «????????????»?????????????????
     SHOP_STATUS_SCROLL_BUTTON = Input::A
     
     # ? ????????????????:‰(??? 1‰=0.1%)?
     # 500 ?? 50.0% ???
     STAND_BY_EXP_RATE = 500
     # ? ?????????????????????????
     # false ???????????????????
     SHOW_STAND_BY_LEVEL_UP = true
   end
end

#???????????????????????????????????????

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

#???????????????????????????????????????
#==============================================================================
# ? KGC::Commands
#==============================================================================

module KGC::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
     #--------------------------------------------------------------------------
     # ? ??????????
     #--------------------------------------------------------------------------
     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
   end
   
   class Game_Interpreter
     include KGC::Commands
   end
   
   #???????????????????????????????????????
   
   #==============================================================================
   # ¦ Vocab
   #==============================================================================
   
   module Vocab
     # ????????????? (????)
     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
   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
       return ($game_temp.in_battle ? battle_members : members_KGC_LargeParty)
     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_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
     # fixed : ????? (??? : false)
     #--------------------------------------------------------------------------
     def fix_actor(actor_id, fixed = false)
       unless @actors.include?(actor_id)
         return
       end
       
       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
       @actors -= @fixed_actors
       @actors = @fixed_actors + @actors
     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
   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.all_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)
       self.z = 1500
       @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)
       self.z = 1000
     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: Retirer",
         "B: Fin",
         "C: Confirmer",
         "X: Classer"
         ]
       when MODE_SHIFT_CHANGE # ????
         buttons = [
         "B: Annuler",
         "C: Confirmer",
         "X: Confirmer"
         ]
       when MODE_PARTY_MEMBER # ????????
         buttons = [
         "B: Annuler",
         "C: Confirmer"
         ]
       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.x = (Graphics.width - @confirm_window.width) / 2
       @confirm_window.y = (Graphics.height - @confirm_window.height) / 2
       @confirm_window.z = 2000
       @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
       
       # ???????????????
       @battle_member_window.x = base_x
       @battle_member_window.y = base_y + CAPTION_OFFSET
       @party_member_window.x = base_x
       @party_member_window.y = @battle_member_window.y +
       @battle_member_window.height + CAPTION_OFFSET
       @status_window.x = 0
       @status_window.y = @party_member_window.y + @party_member_window.height
       
       # ????????????????
       @battle_member_caption_window.x = [base_x - 16, 0].max
       @battle_member_caption_window.y = @battle_member_window.y - CAPTION_OFFSET
       @party_member_caption_window.x = [base_x - 16, 0].max
       @party_member_caption_window.y = @party_member_window.y - CAPTION_OFFSET
       @control_window.x = @status_window.width
       @control_window.y = @status_window.y
     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 = 500
     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 # ????
           # ????????????
           if $game_party.battle_members.size == 0
             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 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, $game_party.battle_members.size > 0)
       @confirm_window.open
       @confirm_window.active = true
     end
     #--------------------------------------------------------------------------
     # ? ???????????
     #--------------------------------------------------------------------------
     def hide_confirm_window
       @confirm_window.active = true
       @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
         Graphics.freeze
         snapshot_for_background
         $scene = Scene_PartyForm.new(0, Scene_PartyForm::HOST_BATTLE)
         $scene.main
         $scene = self
         @status_window.refresh
         perform_transition
       end
     end
   end

Page vue 47032 fois | Auteur : Samarium

Contact - Partenaires - Historique - Utilitaire - A propos