#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/ #_/ ◆ 많은 사람 파티 - KGC_LargeParty ◆ VX ◆ #_/ ◇ Last update : 2008/04/27 ◇ #_/---------------------------------------------------------------------------- #_/ 5명 이상의 대규모 파티를 구축 가능하게 합니다. #_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/ #============================================================================== # ★ 커스터마이즈 항목 - Customize ★ #============================================================================== module KGC module LargeParty # ◆ 파티 편성 허가를 나타내는 스윗치 번호 # 이 스윗치의 ON/OFF 그리고 파티 편성의 허가/불허가 (을)를 바꿉니다. PARTYFORM_SWITCH = 1 # ◆ 전투중의 파티 편성 허가를 나타내는 스윗치 번호 # ↑(와)과 다른 번호를 지정하면, 전투중만의 교체 가부를 설정할 수 있습니다. BATTLE_PARTYFORM_SWITCH = 1 # ◆ 디폴트의 편성 허가 플래그 # true (으)로 하면, 「뉴 게임」선택시에 양쪽 모두의 파티 편성 허가 스윗치가 # 자동적으로 ON (이)가 됩니다. DEFAULT_PARTYFORM_ENABLED = true # ◆ 전투 멤버 최대수 (디폴트치) # 5 이상으로 하면, 전투 화면의 스테이터스가 약간 봐 괴로워집니다. MAX_BATTLE_MEMBERS = 5 # ◆ 파티 멤버 최대수 # Game_Party::MAX_MEMBERS (을)를 덧쓰기합니다. # 100 이상으로 하면 [Window_MenuStatus] 하지만 버그. MAX_MEMBERS = 99 # ◆ 고정 멤버의 줄서 바꾸어를 금지 # 스크립트로부터의 조작 이외에서는 줄서 바꾸어 할 수 없게 됩니다. 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 = "Party" # ◆ 전투중에 파티 편성 커멘드를 사용한다 # 추가하는 장소는, 파티 커멘드의 최하부( 「도망친다」의 아래)입니다. USE_BATTLE_PARTYFORM = true # ◆ 전투중의 파티 편성 커멘드의 명칭 VOCAB_BATTLE_PARTYFORM = "교체" # ◆ 편성 화면의 캐릭터 묘화 사이즈 [폭, 높이] # 액터의 보행 그래픽의 사이즈에 따라 고쳐 써 주세요. PARTY_FORM_CHARACTER_SIZE = [40, 48] # ◆ 편성 화면의 전투 멤버 윈도우의 공난에 표시하는 텍스트 BATTLE_MEMBER_BLANK_TEXT = "EMPTY" # ◆ 편성 화면의 파티 멤버 윈도우의 최대행수 # 스테이터스 윈도우가 화면에서는 봐 나오는 경우는, # 이 값을 1 (으)로 해 주세요. PARTY_MEMBER_WINDOW_ROW_MAX = 2 # ◆ 편성 화면의 파티 멤버 윈도우에 전투 멤버를 표시한다 SHOW_BATTLE_MEMBER_IN_PARTY = false # ◆ 편성 화면의 파티 멤버 윈도우의 공난에 표시하는 텍스트 PARTY_MEMBER_BLANK_TEXT = "" # ◆ 편성 화면의 캡션 윈도우의 폭 CAPTION_WINDOW_WIDTH = 192 # ◆ 편성 화면의 전투 멤버 윈도우의 캡션 BATTLE_MEMBER_CAPTION = "전투 멤버" if SHOW_BATTLE_MEMBER_IN_PARTY # ◆ 편성 화면의 파티 멤버 윈도우의 캡션 # SHOW_BATTLE_MEMBER_IN_PARTY = true 때 PARTY_MEMBER_CAPTION = "파티 멤버" else # ◆ 편성 화면의 파티 멤버 윈도우의 캡션 # SHOW_BATTLE_MEMBER_IN_PARTY = false 때 PARTY_MEMBER_CAPTION = "대기 멤버" end # ◆ 편성 확인 윈도우의 폭 CONFIRM_WINDOW_WIDTH = 160 # ◆ 편성 확인 윈도우의 문자열 # ※커멘드수·차례를 변경하면 버그. CONFIRM_WINDOW_COMMANDS = ["완료", "중지", "취소"] # ◆ 숍 화면의 스테이터스 윈도우 스크롤시에 사용하는 버튼 # 이 버튼을 누르고 있는 동안, 상하 버튼으로 스크롤 할 수 있습니다. # 스크롤을 무효로 하는 경우는 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 # ◆ 전투 이외에도 대기 멤버를 표시한다 # true : 전투 이외에서는 항상 전원을 표시. # false : 교체시 이외는, 대기 멤버를 없는 것으로서 취급한다. SHOW_STAND_BY_MEMBER_NOT_IN_BATTLE = true end 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 #-------------------------------------------------------------------------- # ○ 파티 인원수가 가득한가 #-------------------------------------------------------------------------- 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.all_members.each { |actor| $game_party.remove_battle_member(actor.id) } 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 # 「파티 편성」커멘드명 (메뉴) 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_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 if stand_by_members.include?($game_actors[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 #-------------------------------------------------------------------------- # ○ 멤버 정렬 (승순) # 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 for actor in all_members actor.remove_states_battle end 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 : 능력치의 종류 (03) # 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: 제외한다", "B: 종료", "C: 결정", "X: 줄대체" ] when MODE_SHIFT_CHANGE # 줄대체 buttons = [ "B: 캔슬", "C: 결정", "X: 결정" ] when MODE_PARTY_MEMBER # 파티 멤버 buttons = [ "B: 캔슬", "C: 결정" ] 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 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