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

#_/ ? ??????? - 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 = 4

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

# Game_Party::MAX_MEMBERS ????????

# 100 ?????? [Window_MenuStatus] ???????

MAX_MEMBERS = 12



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

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

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 = false

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] }

return result

end

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

# ? ?????????

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

def stand_by_members

return (all_members - battle_members)

end

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

# ? ?????????

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

def fixed_members

result = []

@fixed_actors.each { |i| result << $game_actors }

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

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

if actor == nil

draw_empty_actor(i)

next

end



if $game_party.actor_fixed?(actor.id)

draw_fixed_back(i)

end

rect = item_rect(i)

opacity = ($game_party.battle_members.include?(actor) ? 96 : 255)

draw_actor_graphic(actor,

rect.x + DRAW_SIZE[0] / 2,

rect.y + DRAW_SIZE[1] - 4,

opacity)

}

end

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

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

# actor : ????

# x : ??? X ??

# y : ??? Y ??

# opacity : ????

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

def draw_actor_graphic(actor, x, y, opacity = 255)

draw_character(actor.character_name, actor.character_index, x, y, opacity)

end

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

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

# character_name : ???????? ?????

# character_index : ???????? ??????

# x : ??? X ??

# y : ??? Y ??

# opacity : ????

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

def draw_character(character_name, character_index, x, y, opacity = 255)

return if character_name == nil

bitmap = Cache.character(character_name)

sign = character_name[/^[\!\$]./]

if sign != nil and sign.include?('$')

cw = bitmap.width / 3

ch = bitmap.height / 4

else

cw = bitmap.width / 12

ch = bitmap.height / 8

end

n = character_index

src_rect = Rect.new((n%4*3+1)*cw, (n/4*4)*ch, cw, ch)

self.contents.blt(x - cw / 2, y - ch, bitmap, src_rect, opacity)

end

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

# ? ????????

# index : ????

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

def draw_empty_actor(index)

rect = item_rect(index)

self.contents.font.color = system_color

self.contents.draw_text(rect, KGC::LargeParty::PARTY_MEMBER_BLANK_TEXT, 1)

self.contents.font.color = normal_color

end

end



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



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

# ? Window_PartyFormStatus

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

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

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



class Window_PartyFormStatus < Window_Base

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

# ? ?????????

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

def initialize

super(0, 0, 384, 128)

self.z = 1000

@actor = nil

refresh

end

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

# ? ??????

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

def set_actor(actor)

if @actor != actor

@actor = actor

refresh

end

end

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

# ? ??????

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

def refresh

self.contents.clear

if @actor == nil

return

end



draw_actor_face(@actor, 0, 0)

dx = 104

draw_actor_name(@actor, dx, 0)

draw_actor_level(@actor, dx, WLH * 1)

draw_actor_hp(@actor, dx, WLH * 2)

draw_actor_mp(@actor, dx, WLH * 3)

4.times { |i|

draw_actor_parameter(@actor, dx + 128, WLH * i, i, 120)

}

end

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

# ? ??????

# actor : ????

# x : ??? X ??

# y : ??? Y ??

# type : ?????? (0~3)

# width : ???

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

def draw_actor_parameter(actor, x, y, type, width = 156)

case type

when 0

parameter_name = Vocab::atk

parameter_value = actor.atk

when 1

parameter_name = Vocab::def

parameter_value = actor.def

when 2

parameter_name = Vocab::spi

parameter_value = actor.spi

when 3

parameter_name = Vocab::agi

parameter_value = actor.agi

end

nw = width - 36

self.contents.font.color = system_color

self.contents.draw_text(x, y, nw, WLH, parameter_name)

self.contents.font.color = normal_color

self.contents.draw_text(x + nw, y, 36, WLH, parameter_value, 2)

end

end



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



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

# ? Window_PartyFormControl

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

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

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



class Window_PartyFormControl < Window_Base

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

# ? ??

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

MODE_BATTLE_MEMBER = 0

MODE_SHIFT_CHANGE = 1

MODE_PARTY_MEMBER = 2

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

# ? ?????????

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

def initialize

super(0, 0, Graphics.width - 384, 128)

self.z = 1000

@mode = MODE_BATTLE_MEMBER

refresh

end

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

# ? ?????

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

def mode=(value)

@mode = value

refresh

end

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

# ? ??????

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

def refresh

self.contents.clear

case @mode

when MODE_BATTLE_MEMBER # ??????

buttons = [

"A: Remove",

"B: End",

"C: Confirm",

"X: Sort"

]

when MODE_SHIFT_CHANGE # ????

buttons = [

"B: Cancel",

"C: Confirm",

"X: Confirm"

]

when MODE_PARTY_MEMBER # ????????

buttons = [

"B: Cancel",

"C: Confirm"

]

else

return

end



buttons.each_with_index { |c, i|

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

}

end

end



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



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

# [ Scene_Title

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



class Scene_Title < Scene_Base

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

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

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

alias create_game_objects_KGC_LargeParty create_game_objects

def create_game_objects

create_game_objects_KGC_LargeParty



if KGC::LargeParty::DEFAULT_PARTYFORM_ENABLED

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

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

end

end

end



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



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

# [ Scene_Map

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



class Scene_Map < Scene_Base

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

# ? ?????????

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

alias update_scene_change_KGC_LargeParty update_scene_change

def update_scene_change

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



if $game_temp.next_scene == :partyform

call_partyform

return

end



update_scene_change_KGC_LargeParty

end

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

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

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

def call_partyform

$game_temp.next_scene = nil

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

end

end



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



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

# [ Scene_Menu

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



class Scene_Menu < Scene_Base

if KGC::LargeParty::USE_MENU_PARTYFORM_COMMAND

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

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

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

alias create_command_window_KGC_LargeParty create_command_window

def create_command_window

create_command_window_KGC_LargeParty



return if $imported["CustomMenuCommand"]



@__command_partyform_index =

@command_window.add_command(Vocab.partyform)

@command_window.draw_item(@__command_partyform_index,

$game_party.partyform_enable?)

if @command_window.oy > 0

@command_window.oy -= Window_Base::WLH

end

@command_window.index = @menu_index

end

end

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

# ? ?????????

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

alias update_command_selection_KGC_LargeParty update_command_selection

def update_command_selection

current_menu_index = @__command_partyform_index

call_partyform_flag = false



if Input.trigger?(Input::C)

case @command_window.index

when @__command_partyform_index # ??????

call_partyform_flag = true

end

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

elsif KGC::LargeParty::MENU_PARTYFORM_BUTTON != nil &&

Input.trigger?(KGC::LargeParty::MENU_PARTYFORM_BUTTON)

call_partyform_flag = true

current_menu_index = @command_window.index if current_menu_index == nil

end



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

if call_partyform_flag

if $game_party.members.size == 0 || !$game_party.partyform_enable?

Sound.play_buzzer

return

end

Sound.play_decision

$scene = Scene_PartyForm.new(current_menu_index)

return

end



update_command_selection_KGC_LargeParty

end

end



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



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

# [ Scene_Shop

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



unless $imported["HelpExtension"]

class Scene_Shop < Scene_Base

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

# ? ??????

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

alias udpate_KGC_LargeParty update

def update

# ???????

if !@command_window.active &&

KGC::LargeParty::SHOP_STATUS_SCROLL_BUTTON != nil &&

Input.press?(KGC::LargeParty::SHOP_STATUS_SCROLL_BUTTON)

super

update_menu_background

update_scroll_status

return

else

@status_window.cursor_rect.empty

end



udpate_KGC_LargeParty

end

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

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

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

def update_scroll_status

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

@status_window.cursor_rect.width = @status_window.contents.width

@status_window.cursor_rect.height = @status_window.height - 32

@status_window.update



if Input.press?(Input::UP)

@status_window.oy = [@status_window.oy - 4, 0].max

elsif Input.press?(Input::DOWN)

max_pos = [@status_window.contents.height -

(@status_window.height - 32), 0].max

@status_window.oy = [@status_window.oy + 4, max_pos].min

end

end

end

end



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



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

# ? Scene_PartyForm

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

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

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



class Scene_PartyForm < Scene_Base

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

# ? ??

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

CAPTION_OFFSET = 40 # ????????????????

HOST_MENU = 0 # ????? : ????

HOST_MAP = 1 # ????? : ???

HOST_BATTLE = 2 # ????? : ??

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

# ? ?????????

# menu_index : ?????????????

# host_scene : ????? (0..???? 1..??? 2..??)

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

def initialize(menu_index = 0, host_scene = HOST_MENU)

@menu_index = menu_index

@host_scene = host_scene

end

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

# ? ????

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

def start

super

create_menu_background



create_windows

create_confirm_window

adjust_window_location



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

@battle_actors = $game_party.battle_members.dup

@party_actors = $game_party.all_members.dup

end

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

# ? ????????

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

def create_windows

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

@battle_member_window = Window_PartyFormBattleMember.new

@party_member_window = Window_PartyFormAllMember.new

@status_window = Window_PartyFormStatus.new

@status_window.set_actor(@battle_member_window.actor)



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

@battle_member_caption_window =

Window_PartyFormCaption.new(KGC::LargeParty::BATTLE_MEMBER_CAPTION)

@party_member_caption_window =

Window_PartyFormCaption.new(KGC::LargeParty::PARTY_MEMBER_CAPTION)

@control_window = Window_PartyFormControl.new

end

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

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

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

def create_confirm_window

commands = KGC::LargeParty::CONFIRM_WINDOW_COMMANDS

@confirm_window =

Window_Command.new(KGC::LargeParty::CONFIRM_WINDOW_WIDTH, commands)

@confirm_window.index = 0

@confirm_window.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

#==============================================================================
# ** Game_Actors
#------------------------------------------------------------------------------
#  This class handles the actor array. The instance of this class is
# referenced by $game_actors.
#==============================================================================

class Game_Actors
  #--------------------------------------------------------------------------
  # * Object Initialization
  #--------------------------------------------------------------------------
  def initialize
    @data = []
  end
  #--------------------------------------------------------------------------
  # * Get Actor
  #    actor_id : actor ID
  #--------------------------------------------------------------------------
  def [](actor_id)
    if @data[actor_id] == nil and $data_actors[actor_id] != nil
      @data[actor_id] = Game_Actor.new(actor_id)
    end
    return @data[actor_id]
  end
end