#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/

#_/ ? ??????? - KGC_LargeParty ? VX ?

#_/ ? Last update : 2008/02/06 ?

#_/----------------------------------------------------------------------------

#_/ 5?????????????????????

#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/



#==============================================================================

# ? ???????? - Customize ?

#==============================================================================



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 = 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 = "Formation"



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

# ????????????????????(???????)???

USE_BATTLE_PARTYFORM = true

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

VOCAB_BATTLE_PARTYFORM = "Reorder"



# ? ???????????????? [?, ??]

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

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 = "Battle Party"



if SHOW_BATTLE_MEMBER_IN_PARTY

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

# SHOW_BATTLE_MEMBER_IN_PARTY = true ???

PARTY_MEMBER_CAPTION = "Party Member"

else

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

# SHOW_BATTLE_MEMBER_IN_PARTY = false ???

PARTY_MEMBER_CAPTION = "Reserve Party"

end



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

CONFIRM_WINDOW_WIDTH = 160

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

# ??????·??????????????

CONFIRM_WINDOW_COMMANDS = ["Confirm Change", "Cancel Change", "Back"]



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

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

# ?????????????? 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: Remove",

"B: End",

"C: Confirm",

"X: Sort"

]

when MODE_SHIFT_CHANGE # ????

buttons = [

"B: Cancel",

"C: Confirm",

"X: Confirm"

]

when MODE_PARTY_MEMBER # ????????

buttons = [

"B: Cancel",

"C: Confirm"

]

else

return

end



buttons.each_with_index { |c, i|

self.contents.draw_text(0, WLH * i, width - 32, WLH, c)

}

end

end



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



#==============================================================================

# ¦ Scene_Title

#==============================================================================



class Scene_Title < Scene_Base

#--------------------------------------------------------------------------

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

#--------------------------------------------------------------------------

alias create_game_objects_KGC_LargeParty create_game_objects

def create_game_objects

create_game_objects_KGC_LargeParty



if KGC::LargeParty::DEFAULT_PARTYFORM_ENABLED

$game_switches[KGC::LargeParty::PARTYFORM_SWITCH] = true

$game_switches[KGC::LargeParty::BATTLE_PARTYFORM_SWITCH] = true

end

end

end



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



#==============================================================================

# ¦ Scene_Map

#==============================================================================



class Scene_Map < Scene_Base

#--------------------------------------------------------------------------

# ? ?????????

#--------------------------------------------------------------------------

alias update_scene_change_KGC_LargeParty update_scene_change

def update_scene_change

return if $game_player.moving? # ??????????



if $game_temp.next_scene == :partyform

call_partyform

return

end



update_scene_change_KGC_LargeParty

end

#--------------------------------------------------------------------------

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

#--------------------------------------------------------------------------

def call_partyform

$game_temp.next_scene = nil

$scene = Scene_PartyForm.new(0, Scene_PartyForm::HOST_MAP)

end

end



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



#==============================================================================

# ¦ Scene_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

=begin #############################
                        Eri's menu
                       
Author: Azuma-01
Version: 2.0
Date: 18 / 05 / 2010
Last Update: 20 / 05 / 2010
=end ##############################
#----------------------------------------------------------- Instructions ------------------------------------------------------------
# pour ajouter des options au menu:
# 1. Autour de la ligne 124, ajouter le nom de votre nouvelle commande
# 2.  Si le nouveau menu a besoin de choisir un acteur, ajouter "la position du menu -1 " a la ligne 184.
#      Sinon, autour de la ligne 190, ajouter ; when la position du menu -1; $scene = Nom_de la scene + .new
# 3. Si le nouveau menu a besoin de choisir un acteur, autour de la ligne 232, ajouter  :
#    when la position du menu -1; $scene = Nom_de la scene + .new(@status_window_index)
# 4. Ajouter le le text d'aide dans le module

#----------------------------------------------------------------------------------------------------------------------------------------
#==================================== History ====================================
# 1.0 (18/05/2010)
#            - sortie du menu
#
# 2.0 (20/05/2010)
#            - Fond pour les faces en option.
#            - Correction le l'alignement centré.

#==============================================================================
module Aza
  module Eri_Menu
 
#=============================================#
#                            ● BEGIN Customization ●                              #
#=============================================#
 
    Reinitialize_Status_Window = true # Quand la sélection d'un acteur est annulé, la position des fenêtres est réinitialisé
 
    Empty_Windows = true # crée au minimum 3 fenêtres pour acteur (même si elles sont vide)
    # Note: les fenêtres vide ne peuvent être sélectionné
 
    Save_Path = "" # dossier des savegardes
 
    No_Save_Disabled_Load = false # permettre de désactiver l'option charger si il existe aucune sauvegarde?
 
    Use_Back_Face = false # utiliser un fond pour les face ?
    Back_Face_Color = Color.new(36, 36, 36) # couleur du fond
 
    $data_system        = load_data("Data/System.rvdata") # ne pas toucher!!
 
    Help_Text = {# messages d'aide
        # "nom de la command" => ["ligne1",
        #                  "ligne2",
        #                  "ligne3",
        #                  "ligne4",],
        Vocab.item => ["Text d'aide pour les obiets."],
               
        Vocab.equip => ["ligne1",
                        "ligne2",
                        "ligne3",
                        "ligne4"],
               
        Vocab.skill => ["ligne1",
                        "ligne2",
                        "ligne3",
                        "ligne4"],
               
        Vocab.status => ["ligne1",
                        "ligne2",
                        "ligne3",
                        "ligne4"],
               
        Vocab.save => ["ligne1",
                        "ligne2",
                        "ligne3",
                        "ligne4"],
               
        Vocab.game_end => ["ligne1",
                        "ligne2",
                        "ligne3",
                        "ligne4"],
               
    } # <-- do not remove
 
    Text = {
      :menu_word => "Menu",
      :time_text => "Temps de jeu"
    } # <-- do not remove
 
    Text_Color = { # couleur des textes
      :menu_word => Color.new(0, 255, 255),
      :location => Color.new(255, 255, 0),
      :gold_text => Color.new(255, 0, 255),
      :gold_value => Color.new(0, 0, 255),
      :time_text => Color.new(36, 36, 36),
      :time_value => Color.new(255, 0, 0),
      :help_text => Color.new(0, 255, 0),
      :commands => Color.new(255, 255, 255)
    } # <-- do not remove
 
#============================================#
#                              ● END Customization ●                              #
#============================================#
  end
end

$AzaScritps ||= {}
$AzaScritps['Azuma-01_Menu_for_Eri'] = true
#==============================================================================
# ■ Scene Menu
#==============================================================================
class Scene_Menu
  #--------------------------------------------------------------------------
  # * Create Command Window
  #--------------------------------------------------------------------------
  def create_command_window
    @commands = [
    #-----------------------------------------------
      # "nom de la commande",
      Vocab.item,
      Vocab.equip,
      Vocab.skill,
      Vocab.status,
      Vocab.partyform,
      Vocab.save,
      Vocab.game_end,
 
    #-----------------------------------------------
    ] # <-- do not remove
    @command_windows = []
    @commands.size.times{|i|
      @command_windows.push(Window_Eri_Command.new(@commands[i], 0, 82 + (i * 34)))
      @command_windows[i].z = 300
    }
    show_command(@menu_index)
    @command_window_index = @menu_index
    @command_windows[@menu_index].x += 15
    @command_windows[@menu_index].selected = true
    @max_item = @commands.size
    if $game_party.members.size == 0          # If number of party members is 0
      draw_item(0, false)    # Disable item
      draw_item(1, false)    # Disable equipment
      draw_item(2, false)    # Disable skill
      draw_item(3, false)    # Disable status
    end
    if $game_system.save_disabled            # If save is forbidden
      draw_item(5, false)    # Disable save
    end
    # Si vous utiliser un menu de chargement, enlever le "#" des 3 lignes qui suis
#    if $game_system.load_disabled or !load_enabled?            # If load is forbidden
#      draw_item(5, false)    # Disable load
#    end
  end
 
  #--------------------------------------------------------------------------
  # * Update Command Selection
  #--------------------------------------------------------------------------
  def update_command_selection
    last_actor = @command_window_index
    if Input.trigger?(Input::B)
      Sound.play_cancel
      $scene = Scene_Map.new
    elsif Input.repeat?(Input::RIGHT) or Input.repeat?(Input::DOWN)
      commands_down
    elsif Input.repeat?(Input::LEFT) or Input.repeat?(Input::UP)
      commands_up
    elsif Input.trigger?(Input::C)
      if $game_party.members.size == 0 and @command_window_index < 5
        Sound.play_buzzer
        return
      elsif $game_system.save_disabled and @command_window_index == 5
        Sound.play_buzzer
        return
        # Si vous utiliser un menu de chargement, enlever le "#" des 3 lignes qui suis
#      elsif ($game_system.load_disabled or !load_enabled?) and @command_window_index == 5
#        Sound.play_buzzer
#        return
      end
      Sound.play_decision
      case @command_window_index
      #
      #------------------------------------------------------
#      when x
#        $scene = Nom_de la scene + .new
      when 0      # Item
        $scene = Scene_Item.new
      when 1,2,3  # equipment, Skill, status
        start_actor_selection
      when 4
        $scene = Scene_PartyForm.new
      when 5      # Save
        $scene = Scene_File.new(true, false, false)
      when 6      # End Game
        $scene = Scene_End.new

 
      #------------------------------------------------------
      #
      end
    end
    if last_actor != @command_window_index
      Sound.play_cursor
      @help_window.set_text(Aza::Eri_Menu::Help_Text[@commands[@command_window_index]])
      @command_windows[@command_window_index].selected = true
      @command_windows[@command_window_index].x += 15
      @command_windows[last_actor].selected = false
      @command_windows[last_actor].x -= 15
    end
  end
 
  #--------------------------------------------------------------------------
  # * Update Actor Selection
  #--------------------------------------------------------------------------
  def update_actor_selection
    last_actor = @status_window_index
    if Input.trigger?(Input::B)
      Sound.play_cancel
      end_actor_selection
    elsif Input.repeat?(Input::RIGHT) or Input.repeat?(Input::DOWN)
      cursor_down
    elsif Input.repeat?(Input::LEFT) or Input.repeat?(Input::UP)
      cursor_up
    elsif Input.trigger?(Input::C)
      $game_party.last_actor_index = @status_window_index
      Sound.play_decision
      case @command_window_index
      #
      #------------------------------------------------------
#      when x
#        $scene = Nom_de la scene + .new(@status_window_index) # en règle gégérale
      when 1  # equipment
        $scene = Scene_Equip.new(@status_window_index)
      when 2  # skill
        $scene = Scene_Skill.new(@status_window_index)
      when 3  # status
        $scene = Scene_Status.new(@status_window_index)
 
      #------------------------------------------------------
      #
      end
    end
    if last_actor != @status_window_index
      Sound.play_cursor
      @status_windows[@status_window_index].selected = true
      @status_windows[last_actor].selected = false
    end
  end
 
  #--------------------------------------------------------------------------
  # * Determine if Load is Enabled
  #--------------------------------------------------------------------------
  def load_enabled?
    return true if !Aza::Eri_Menu::No_Save_Disabled_Load
    path = Aza::Eri_Menu::Save_Path == "" ? "" : Aza::Eri_Menu::Save_Path + "/"
    return (Dir.glob(path + 'Save*.rvdata').size > 0)
  end
 
 
  def draw_item(index, enabled = true)
    @command_windows[index].refresh(enabled)
  end

  #--------------------------------------------------------------------------
  # * Start processing
  #--------------------------------------------------------------------------
  def start
    super
    create_menu_background
    create_command_window
    @fake_command = Window_Base.new(0, 80, 160 , 208)
    @fake_command.opacity = 0; @fake_command.z = 301
    create_fake_commands if @max_item > 6
    @help_window = Window_Help4.new(128, 288, 416, 128)
    @help_window.set_text(Aza::Eri_Menu::Help_Text[@commands[@command_window_index]])
    @goldtime_window = Window_Menu_GoldTime.new(0, 288)
    @locaton_window = Window_Location.new
    @coner = Window_Base.new(0, 0, 50, 80)
    @menu = Window_Base.new(15, 0, 120, 60)
    @menu.contents.font.size = 28
    @menu.contents.font.color = Aza::Eri_Menu::Text_Color[:menu_word]
    @menu.contents.draw_text(0, 0, 88,28, Aza::Eri_Menu::Text[:menu_word], 1)
    create_status_windows
    @command_window_active = true
    @status_window_active = false
  end
 
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    super
    update_menu_background
    @command_windows.each{|window| window.update}
    @goldtime_window.update
    @locaton_window.update
    @help_window.update
    @status_windows.each{|window| window.update}
    @fake_command.update
    @fake_sprite.update
    if @command_window_active
      update_command_selection
    elsif @status_window_active
      update_actor_selection
    end

  end
 
  #--------------------------------------------------------------------------
  # * Termination Processing
  #--------------------------------------------------------------------------
  def terminate
    super
    dispose_menu_background
    @command_windows.each{|window| window.dispose}
    @goldtime_window.dispose
    @locaton_window.dispose
    @help_window.dispose
    @coner.dispose
    @menu.dispose
    @status_windows.each{|window| window.dispose}
    @fake_sprite.dispose
    @fake_command.dispose
  end
 
  #--------------------------------------------------------------------------
  # * Create Status Windows
  #--------------------------------------------------------------------------
  def create_status_windows
    @status_windows = []
    members = $game_party.members
    if members.size < 3 and Aza::Eri_Menu::Empty_Windows
      (3 - members.size).times{members.push(nil)}
    end
    members.each_with_index{|actor, i|
      x = 160 + (i * 128)
      y = 66
      @status_windows[i] = Window_Menu_Status.new(actor, x , y)
    }
    @fake_sprite = Window_Base.new(160, 82, 384 , 208)
    @fake_sprite.opacity = 0; @fake_sprite.z = 301
    show_actor(0)
    create_fake_contents if $game_party.members.size > 3
  end
 
  #--------------------------------------------------------------------------
  # * Move Commands Windows Untill The Active Commands Is Visible
  #    index : Actor index
  #--------------------------------------------------------------------------
  def show_command(index)
    loop do
      y = @command_windows[index].y
      if y < 80
        @command_windows.each{|window| window.y += 34}
      elsif y > 285
        @command_windows.each{|window| window.y -= 34}
      end
      break if @command_windows[index].y > 80 and @command_windows[index].y < 285
    end
    @command_windows.each{|window|
      if window.y < 80 or window.y > 285
        window.visible = false
      else; window.visible = true
      end
    }
  end
 
  #--------------------------------------------------------------------------
  # * Move Actors Windows Untill The Active Actor Is Visible
  #    index : Actor index
  #--------------------------------------------------------------------------
  def show_actor(index)
    loop do
      x = @status_windows[index].x
      if x < 150
        @status_windows.each{|window| window.x += 128}
      elsif x > 540
        @status_windows.each{|window| window.x -= 128}
      end
      break if @status_windows[index].x > 150 and @status_windows[index].x < 540
    end
    @status_windows.each{|window|
      if window.x < 150 or window.x > 540
        window.visible = false
      else; window.visible = true
      end
    }
  end
 
  #--------------------------------------------------------------------------
  # * Create Fake Actor Box
  #--------------------------------------------------------------------------
  def create_fake_contents
    @fake_sprite.contents.dispose
    if $game_party.members.size > 3
      ox = @status_windows[$game_party.members.size - 1].visible ?  32 : @status_windows[0].visible ? 0 : 16
      @fake_sprite.contents = Bitmap.new(@fake_sprite.width, @fake_sprite.height - 32)
      @fake_sprite.ox = ox
    else
      @fake_sprite.contents = Bitmap.new(@fake_sprite.width - 32, @fake_sprite.height - 32)
    end
  end
 
  #--------------------------------------------------------------------------
  # * Create Fake Commands Box
  #--------------------------------------------------------------------------
  def create_fake_commands
    @fake_command.contents.dispose
    if @max_item > 6
      @command_windows[@max_item - 1].y
      oy = @command_windows[@max_item - 1].visible ?  32 : @command_windows[0].visible ? 0 : 16
      @fake_command.contents = Bitmap.new(@fake_command.width - 32, @fake_command.height)
      @fake_command.oy = oy
    else
      @fake_command.contents = Bitmap.new(@fake_command.width - 32, @fake_sprite.height - 32)
    end
  end
 
  #--------------------------------------------------------------------------
  # * Start Actor Selection
  #--------------------------------------------------------------------------
  def start_actor_selection
    @command_window_active = false
    if $game_party.last_actor_index < $game_party.members.size
      @status_window_index = $game_party.last_actor_index
    else
      @status_window_index = 0
    end
    @status_windows[@status_window_index].selected = true
    @status_window_active = true
    show_actor(@status_window_index)
    create_fake_contents if $game_party.members.size > 3
  end
 
  #--------------------------------------------------------------------------
  # * End Actor Selection
  #--------------------------------------------------------------------------
  def end_actor_selection
    @command_window_active = true
    @status_windows[@status_window_index].selected = false
    @status_window_active = false
    show_actor(0) if Aza::Eri_Menu::Reinitialize_Status_Window
    create_fake_contents if $game_party.members.size > 3
  end
 
  #--------------------------------------------------------------------------
  # * Move commands down
  #    wrap : Wraparound allowed
  #--------------------------------------------------------------------------
  def commands_down(wrap = false)
    if (@command_window_index < @max_item - 1) or (wrap)
      @command_window_index = (@command_window_index + 1) % @max_item
      return if @command_windows[@command_window_index].visible
      show_command(@command_window_index)
    end
    create_fake_commands if @max_item > 6
  end
 
  #--------------------------------------------------------------------------
  # * Move commands up
  #    wrap : Wraparound allowed
  #--------------------------------------------------------------------------
  def commands_up(wrap = false)
    if (@command_window_index >= 1) or (wrap)
      @command_window_index = (@command_window_index - 1 + @max_item) % @max_item
      return if @command_windows[@command_window_index].visible
      show_command(@command_window_index)
    end
    create_fake_commands if @max_item > 6
  end
 
  #--------------------------------------------------------------------------
  # * Move cursor down
  #    wrap : Wraparound allowed
  #--------------------------------------------------------------------------
  def cursor_down(wrap = false)
    if (@status_window_index < $game_party.members.size - 1) or (wrap)
      @status_window_index = (@status_window_index + 1) % $game_party.members.size
      return if @status_windows[@status_window_index].visible
      show_actor(@status_window_index)
    end
    create_fake_contents if $game_party.members.size > 3
  end
 
  #--------------------------------------------------------------------------
  # * Move cursor up
  #    wrap : Wraparound allowed
  #--------------------------------------------------------------------------
  def cursor_up(wrap = false)
    if (@status_window_index >= 1) or (wrap)
      @status_window_index = (@status_window_index - 1 + $game_party.members.size) % $game_party.members.size
      return if @status_windows[@status_window_index].visible
      show_actor(@status_window_index)
    end
    create_fake_contents if $game_party.members.size > 3
  end
 
end

#==============================================================================
# ■ Game System
#==============================================================================
class Game_System
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
  attr_accessor :load_disabled
 
  #--------------------------------------------------------------------------
  # * Alias Object Initialization
  #--------------------------------------------------------------------------
  alias aza_eri_menu_load_option initialize
  def initialize
    aza_eri_menu_load_option
    @load_disabled = false
  end
 
end

#==============================================================================
# ■ Game Map
#==============================================================================
class Game_Map
  #--------------------------------------------------------------------------
  # * Alias Object Initialization
  #--------------------------------------------------------------------------
  alias aza_eri_menu_map initialize
  def initialize
    aza_eri_menu_map
    @map_name = load_data("Data/MapInfos.rvdata")
  end
 
  #--------------------------------------------------------------------------
  # * Get Map Name
  #--------------------------------------------------------------------------
  def map_name
    return "" if @map_id == 0
    @map_name ||= load_data("Data/MapInfos.rvdata")
    return @map_name[@map_id].name
  end
 
end

#==============================================================================
# ■ Window Menu GoldTime
#==============================================================================
class Window_Menu_GoldTime < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #    x : window X coordinate
  #    y : window Y coordinate
  #--------------------------------------------------------------------------
  def initialize(x, y)
    super(x, y, 128, 128)
    refresh
  end
 
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    self.contents.font.color = Aza::Eri_Menu::Text_Color[:gold_text]
    self.contents.draw_text(0, 0, 96, 24, Vocab::gold)
    self.contents.font.color = Aza::Eri_Menu::Text_Color[:gold_value]
    self.contents.draw_text(0, 24, 96, 24, $game_party.gold)
    self.contents.font.color = Aza::Eri_Menu::Text_Color[:time_text]
    self.contents.draw_text(0, 48, 96, 24, Aza::Eri_Menu::Text[:time_text])
    @total_sec = Graphics.frame_count / Graphics.frame_rate
    hour = @total_sec / 60 / 60 #% 24
    min = @total_sec / 60 % 60
    sec = @total_sec % 60
    text = sprintf("%02d:%02d:%02d", hour, min, sec)
    self.contents.font.color = Aza::Eri_Menu::Text_Color[:time_value]
    self.contents.draw_text(0, 72, 96, 24, text)
  end
 
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    super
    refresh if Graphics.frame_count / Graphics.frame_rate != @total_sec
  end
 
end

#==============================================================================
# ■ Window Menu Status
#==============================================================================
class Window_Menu_Status < Window_Base
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
    attr_reader  :selected
 
  #--------------------------------------------------------------------------
  # * Object Initialization
  #    actor : actor
  #    x : window X coordinate
  #    y : window Y coordinate
  #--------------------------------------------------------------------------
  def initialize(actor, x, y)
    @window =  Window_Actor_Menu.new(x, y + 112, 128, 116)
    super(x, y, 128, 208)
    @actor = actor
    refresh
    self.opacity = 0
    self.active = false
  end
 
  def draw_face(face_name, face_index, x, y, actor, size = 96)
    bitmap = Cache.face(face_name)
    rect = Rect.new(0, 0, 0, 0)
    rect.x = face_index % 4 * 96 + (96 - size) / 2
    rect.y = face_index / 4 * 96 + (96 - size) / 2
    rect.width = size
    rect.height = size
    self.contents.blt(x, y, bitmap, rect)
    bitmap.dispose
    if $game_party.members.include?(actor)
    else
      self.contents.gradient_fill_rect(x, y, 96, 96, Color.new(200, 200, 200, 100), Color.new(100, 100, 100, 100))
    end
   
  end

  def draw_actor_face_space(actor, x, y, size = 96)
    draw_face(actor.face_name, actor.face_index, x, y, actor, size)
  end

  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    @window.contents.clear
    self.contents.fill_rect(0,0,96,96, Aza::Eri_Menu::Back_Face_Color) if Aza::Eri_Menu::Use_Back_Face
    return if @actor.nil?
    draw_actor_face_space(@actor, 0, 0, 96)
    @window.contents.font.size = 19
    @window.draw_actor_name(@actor, 0, 0)
    @window.draw_actor_level(@actor, 0, 21)
    @window.draw_actor_hp(@actor, 0, 42, 96)
    @window.draw_actor_mp(@actor, 0, 63, 96)
  end
 
  #--------------------------------------------------------------------------
  # * Dispose
  #--------------------------------------------------------------------------
  def dispose
    super
    @window.dispose
  end
 
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    super
    @window.update
  end
 
  #--------------------------------------------------------------------------
  # * Set Window X Coordinate
  #--------------------------------------------------------------------------
  def x=(new_x)
    super
    @window.x = new_x
  end
 
  #--------------------------------------------------------------------------
  # * Set Window Y Coordinate
  #--------------------------------------------------------------------------
  def y=(new_y)
    super
    @window.y = new_y + 112
  end
 
  #--------------------------------------------------------------------------
  # * Set Window Z Coordinate
  #--------------------------------------------------------------------------
  def z=(new_z)
    super
    @window.z = new_z
  end
 
  #--------------------------------------------------------------------------
  # * Set Window Visibility
  #--------------------------------------------------------------------------
  def visible=(flag)
    super
    @window.visible = flag
  end
 
  #--------------------------------------------------------------------------
  # * Set Selected
  #    selected : new selected (true = selected, false = unselected)
  #--------------------------------------------------------------------------
  def selected=(selected)
    @selected = selected
    update_cursor
  end
 
  #--------------------------------------------------------------------------
  # * Update cursor
  #--------------------------------------------------------------------------
  def update_cursor
    if @selected
      @window.cursor_rect.set(0, 0, 96, 21)
    else
      @window.cursor_rect.empty
    end
  end
 
end

#==============================================================================
# ■ Window Actor Menu
#==============================================================================
class Window_Actor_Menu < Window_Base
 
#--------------------------------------------------------------------------
  # * Draw Name
  #    actor : actor
  #    x    : draw spot x-coordinate
  #    y    : draw spot y-coordinate
  #--------------------------------------------------------------------------
  def draw_actor_name(actor, x, y)
    self.contents.font.color = hp_color(actor)
    self.contents.draw_text(x, y, 88, WLH, actor.name, 1)
  end
 
  #--------------------------------------------------------------------------
  # * Draw HP
  #    actor : actor
  #    x    : draw spot x-coordinate
  #    y    : draw spot y-coordinate
  #    width : Width
  #--------------------------------------------------------------------------
  def draw_actor_hp(actor, x, y, width = 96)
    gw = width * actor.hp / actor.maxhp
    gc1 = hp_gauge_color1
    gc2 = hp_gauge_color2
    self.contents.fill_rect(x, y + WLH - 8, width, 4, gauge_back_color)
    self.contents.gradient_fill_rect(x, y + WLH - 8, gw, 4, gc1, gc2)
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 30, WLH, Vocab::hp_a)
    self.contents.font.color = hp_color(actor)
    last_font_size = self.contents.font.size
    self.contents.draw_text(30, y, 66, WLH, "#{actor.hp} / #{actor.maxhp}", 2)
  end
 
  #--------------------------------------------------------------------------
  # * Draw MP
  #    actor : actor
  #    x    : draw spot x-coordinate
  #    y    : draw spot y-coordinate
  #    width : Width
  #--------------------------------------------------------------------------
  def draw_actor_mp(actor, x, y, width = 96)
    gw = width * actor.mp / [actor.maxmp, 1].max
    gc1 = mp_gauge_color1
    gc2 = mp_gauge_color2
    self.contents.fill_rect(x, y + WLH - 8, width, 4, gauge_back_color)
    self.contents.gradient_fill_rect(x, y + WLH - 8, gw, 4, gc1, gc2)
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 30, WLH, Vocab::mp_a)
    self.contents.font.color = mp_color(actor)
    last_font_size = self.contents.font.size
    self.contents.draw_text(30, y, 66, WLH, "#{actor.mp} / #{actor.maxmp}", 2)
  end
 
end

#==============================================================================
# ■ Window Eri Command
#==============================================================================
class Window_Eri_Command < Window_Base
  #--------------------------------------------------------------------------
  # * Public Instance Variables
  #--------------------------------------------------------------------------
    attr_reader  :selected
 
  #--------------------------------------------------------------------------
  # * Object Initialization
  #    text : Text
  #    x : window X coordinate
  #    y : window Y coordinate
  #--------------------------------------------------------------------------
  def initialize(text, x, y)
    @text = text
    @sprite = Sprite.new
    @sprite.bitmap = Bitmap.new(150, 24)
    refresh
    super(x, y, 160, 34)
    @selected = false
  end
 
  #--------------------------------------------------------------------------
  # * Create Window Contents
  #--------------------------------------------------------------------------
  def create_contents
    self.contents.dispose
    self.contents = Bitmap.new(1, 1)
  end
 
  #--------------------------------------------------------------------------
  # * Refresh
  #    enabled : enabled flag. When false, draw semi-transparently.
  #--------------------------------------------------------------------------
  def refresh(enabled = true)
    @sprite.bitmap.clear
    @sprite.bitmap.font.color = Aza::Eri_Menu::Text_Color[:commands]
    @sprite.bitmap.font.color.alpha = enabled ? 255 : 128
    @sprite.bitmap.draw_text(4, 0, 146, 24, @text)
  end
 
  #--------------------------------------------------------------------------
  # * Frame Update
  #--------------------------------------------------------------------------
  def update
    super
    @sprite.update
  end
 
  #--------------------------------------------------------------------------
  # * Dispose
  #--------------------------------------------------------------------------
  def dispose
    super
    @sprite.bitmap.dispose
    @sprite.dispose
  end
 
  #--------------------------------------------------------------------------
  # * Set Window X Coordinate
  #--------------------------------------------------------------------------
  def x=(new_x)
    super
    @sprite.x = new_x + 5
  end
 
  #--------------------------------------------------------------------------
  # * Set Window Y Coordinate
  #--------------------------------------------------------------------------
  def y=(new_y)
    super
    @sprite.y = new_y + 5
  end
 
  #--------------------------------------------------------------------------
  # * Set Window Z Coordinate
  #--------------------------------------------------------------------------
  def z=(new_z)
    super
    @sprite.z = new_z
  end
 
  #--------------------------------------------------------------------------
  # * Set Window Visibility
  #--------------------------------------------------------------------------
  def visible=(flag)
    super
    @sprite.visible = flag
  end

  #--------------------------------------------------------------------------
  # * Set Selected
  #    selected : new selected (true = selected, false = unselected)
  #--------------------------------------------------------------------------
  def selected=(selected)
    @selected = selected
    update_cursor
  end
 
  #--------------------------------------------------------------------------
  # * Update cursor
  #--------------------------------------------------------------------------
  def update_cursor
    if @selected
      self.cursor_rect.set(-11, -11, 149, 23)
    else
      self.cursor_rect.empty
    end
  end
 
end

#==============================================================================
# ■ Window Help4
#==============================================================================
class Window_Help4 < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize(x, y, w, h)
    super(x, y, w, h)
  end
 
  #--------------------------------------------------------------------------
  # * Set Text
  #  text  : character string displayed in window
  #  align : alignment (0..flush left, 1..center, 2..flush right)
  #--------------------------------------------------------------------------
  def set_text(text, align = 0)
    if text != @text or align != @align
      self.contents.clear
      return if text.nil?
      self.contents.font.color = Aza::Eri_Menu::Text_Color[:help_text]
      text.each_with_index{|message, i| self.contents.draw_text(4, WLH * i, self.width - 40, WLH, message.to_s, align)}
      @text = text
      @align = align
    end
  end
 
end

#==============================================================================
# ■ Window Location
#==============================================================================
class Window_Location < Window_Base
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    super(70, 0, 474, 80)
    refresh
  end
 
  #--------------------------------------------------------------------------
  # * Refresh
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    self.contents.font.color = Aza::Eri_Menu::Text_Color[:location]
    self.contents.draw_text(0, 24, width - 32, 24, $game_map.map_name, 2)
  end

end
#==============================================================================
# ■ Scene Equip
#==============================================================================
class Scene_Equip
  #--------------------------------------------------------------------------
  # * Return to Original Screen
  #--------------------------------------------------------------------------
  def return_scene
    $scene = Scene_Menu.new(1)
  end
 
end

#==============================================================================
# ■ Scene Skill
#==============================================================================
class Scene_Skill
  #--------------------------------------------------------------------------
  # * Return to Original Screen
  #--------------------------------------------------------------------------
  def return_scene
    $scene = Scene_Menu.new(2)
  end
 
end