Résolu]Modifier l'ouverture d'une fenêtre ...

code]#===============================================================================
#
# Yanfly Engine Zealous - Status Command Menu
# Last Date Updated: 2009.12.29
# Level: Normal, Hard, Lunatic
#
# The status menu in RPG Maker games don't get used much. That's mostly because
# a lot of the information it displays can be seen elsewhere with a lot more
# functionality at those other locations. This script rewrites the status scene
# to not only display even more information, but to also function as a bridge
# to many other scenes.
#
#===============================================================================
# Updates
# -----------------------------------------------------------------------------
# o 2009.12.29 - Stable command window oy switching.
# o 2009.12.27 - Weapon Mastery Skills Compatibility.
# o 2009.12.20 - Parameter window now lines up stats through all actors.
# More efficient import command searching method.
# o 2009.12.16 - Class Stat: LUK Compatibility
# o 2009.12.14 - Formation Macros Compatibility
# o 2009.12.12 - Finished Script.
# o 2009.12.11 - Started Script.
#===============================================================================
# Instructions
# -----------------------------------------------------------------------------
# To install this script, open up your script editor and copy/paste this script
# to an open slot below ▼ Materials but above ▼ Main. Remember to save.
#
#===============================================================================
# Compatibility
# -----------------------------------------------------------------------------
# - Works With: YEZ Battler Stat DEX, Battler Stat RES, Class Stat DUR
# YEZ Formation Macros
# - Overwrites: The entire Status Menu scene.
# -----------------------------------------------------------------------------
# Note: This script may not work with former Yanfly Engine ReDux scripts.
# Use Yanfly Engine Zealous scripts to work with this if available.
#===============================================================================

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

module YEZ
module STATUS

#===========================================================================
# Command Window Options
# -------------------------------------------------------------------------
# The status scene's command window now offers a selection of items to view
# different data and the ability to venture to different menus. However,
# there may be some menu items that not every user wants or would like to
# add. Adjust the COMMANDS constant to modify the command menu order.
# :parameters - Basic stats such as ATK, DEF, SPI, and AGI.
# :affinities - Elemental and Status resistances.
# :skills - Actor's battle skill list.
# :equips - Actor's worn equipment.
# :formations - Requires BEZ Formation Macros.
# :mastery - Requires YEZ Weapon Mastery Skills
# :biography - A biography of the actor.
#===========================================================================
COMMANDS =[
:parameters, # Basic stats such as ATK, DEF, SPI, and AGI.
:affinities, # Elemental and Status resistances.
# :skills, # Actor's battle skill list.
# :equips, # Actor's worn equipment.
:formations, # Requires BEZ Formation Macros.
# :mastery, # Requires YEZ Weapon Mastery Skills
:biography, # A biography of the actor.
] # Do not remove this.

# Do you want your commands to use icons? If you do, set this to true and
# adjust the settings below to use the appropiate icons for your menu.
USE_ICONS = false

# This determines the colour of the EXP bars used for the actor's exp
# gauge in the status menu.
EXP_TEXT = "EXP" # Text used for EXP
PERCENT_EXP = "%1.2f%%" # Text format used for EXP percentage
EXP_GAUGE_1 = 28 # Colour 1 for the EXP Gauge
EXP_GAUGE_2 = 29 # Colour 2 for the EXP Gauge

# The following will determine whether or not your Status Menu will use a
# background image instead of the typical window skin. Place the BG Image
# in the Graphics\System folder if you plan to use it.
USE_BG_IMAGE = false
BG_FILE_NAME = "MenuStatus"

# Parameters Status Mini Window. This window displays the primary stats of
# the actor being viewed. If KGC Parameter Distribution is installed, this
# command will also take the player to the stat distribution scene.
PARAMETERS ={
:title => "Status",
:icon => 103,
# The following adjusts the stats shown in each column. Adjust the array
# for each column to list what order you'd like for the stats to appear.
# :hp, :mp, :blank, :atk, :def, :spi, :res, :dex, :agi
# :hit, :eva, :cri, :dur, :luk, :odds
:page_title => " Caractéristique",
:column1_stats => [:hp, :mp, :blank, :atk, :def, :spi, :res, :dex, :agi],
:column2_stats => [:hit, :eva, :cri, :dur, :luk, :odds],
} # Do not remove this.

# Affinities Mini Window. This window will display the actor's elemental
# and status resistances.
AFFINITIES ={
:title => "Résistance",
:icon => 100,
# The following adjusts what elements and states are shown. Adjust the
# array to meet the state and element ID's. And since elements don't have
# an innate icon associated with them, use the following below to adjust
# the elements used for the elements.
:states_shown => [2 .. 7, 22 .. 24],
:states_title => "Resistance aux effets négatifs",
:elements_shown => [9 ..16],
:elements_title => "Resistance aux éléments",
:element_icons => {
9 => 104,
10 => 105,
11 => 106,
12 => 107,
13 => 108,
14 => 109,
15 => 110,
16 => 111,
}, # Do not remove this.
# The rank colour adjusts the different colours used for each milestone
# percentile achieved by the actor. Values below are text colours.
:rank_colour => {
:srank => 2,
:arank => 2,
:brank => 14,
:crank => 6,
:drank => 3,
:erank => 4,
:frank => 5,
}, # Do not remove this.
:rank_size => 16, # This adjusts the font size used for ranks.
:absorb => "*", # This adjusts symbol used for absorbed elements.
} # Do not remove this.

# Skills Mini Window.This will display a short list of the actor's skills.
# If :battle_only is set to true, the skills will be highlightened and lit
# up like they are usable in battle and don't have the disabled colour.
SKILLS ={
:title => "Magie",
:icon => 159,
:battle_only => true,
} # Do not remove this.

# Equips Mini Window. This mini window will show the actor's equipment
# and the total stat boost accumulated from the equipment. Stat list:
# :hp, :mp, :blank, :atk, :def, :spi, :res, :dex, :agi
# :hit, :eva, :cri, :dur, :luk, :odds
EQUIPS ={
:title => "Equipement",
:icon => 44,
:page_title => "Equipement",
:param => [:hp, :mp, :atk, :def, :spi, :res, :dex, :agi]
} # Do not remove this.

# Biography Mini Window. The following will allow you to adjust biographies
# for actors and classes. If an actor does not have a personal biography,
# then the description of the character's class will be displayed instead.
# If the character's class does not have a description, then this option
# will not appear at all in the status menu.
BIOGRAPHY ={
:title => "Biography",
:icon => 141,
:font_size => 18,
:actor_bio => "%s's Biography",
:class_des => "%s Description",
} # Do not remove this.

# When typing out biographies and descriptions, use \\N[x] to write out
# the actor's name if the game allows renaming. For line splits, use |
# at the each position you would want the description to start a new line.
ACTOR_BIOS ={ # If an actor ID is not listed here, then refer to class bio.
# ID => Bio
1 => 'Habitant du village Potos, Cloud a presque toujours été un solitaire|' +
'qui aime se rendre utile. Il aime Ayanna, mais elle n a jamais|' +
' fait attention à lui. Une nuit, Cloud et Ayanna se rendre dans|' +
' la grotte du village, en dessinant leur portrait sur le mur de cette|' +
'grotte ses deux là ce sont rapprocher. Cloud ne connaît rien de |' +
'ses parents ni même ses origines, mais il espère un jour avoir|'+
'avoir la chance de les découvrir ',
2 => 'Née dans la forêt Lamador avec son père Charles et sa|' +
'maman Marie, Kisouffly est une fille qui aime|' +
'partir à l aventure depuis qu elle est toute petite. |' +
'Elle a été formée dans l art de chasser les animaux|' +
'et autres bêtes sauvages pour apprendre à survivre.|' +
'Tofu, dernier descendant de sa race les Waku, est son meilleur ami. |' +
'Un jour elle va rencontrer Cloud, très intéresser par son histoire|' +
'elle décide de se rendre chez Lucie pour l aider à utiliser les anciennes|' +
'sphères des trilordiens que l on appelle "Matéria".',
3 => 'Née à Arcadia, Fleur est d une longue lignée de Sorcière. Elle n était|' +
'qu une enfant quand elle perdit son père. Chaos, Djinn de Méphisto|' +
'va utiliser sa conscience pour la rendre plus forte et prendre|' +
'possession de son âme. Depuis ce jour elle habite dans un manoir|' +
'au-dessus de la vallée de Gaia. Cloud, Kisouffly décide de partir|' +
'à sa rencontre pour éclaircir le mystère du village de Fanklord.|' +
'. Quand elle va rencontrer nos amis, celle-ci va reprendre ses esprits,|' +
'elle décide de se joindre à eux pour tenter de retrouver sa mère. ',
4 => 'Engagé à l âge de 17 ans et aujourd hui Chef de l armée de Fanklord, |' +
'Alex possède une force qui a aguerri grâce à ses origines trilordiens.|' +
'Quoique certaines personnes ont une très mauvaise impression de|' +
'cette tribu, Alex est considéré par la plupart des habitants comme un |' +
'Fabulien. Alex connaît d ailleurs beaucoup de langue étrangère grâce |' +
'à ses origines.En allant inspecter le manoir depuis la disparition des |' +
'villageois, celui-ci va être capturé en enfermer dans un cachot. ',
} # Do not remove this.

# Just like the actor biographies, use \\N[x] to write out a changeable
# actor's name and \\V[x] to write out variables. Use | to enforce a
# line break. If a class bio is not listed, it will not be shown.
CLASS_BIOS ={ # If a class does not have a bio, it becomes unlisted.
# ID => Bio
1 => 'Knights are quick and powerful characters|' +
'that excel in both melee and magic.',
2 => 'Warriors are very dedicated to close ranged|' +
'physical combat.',
3 => 'Priests focus on healing and aiding their|' +
"party members. Don't let \\N[3] fool you.",
4 => 'Magicians excel in the magical arts and also|' +
'excel at blasting their enemies to bits.',
} # Do not remove this.

end # STATUS
end # YEZ

#===============================================================================
# Status Command Menu - Lunatic Mode - Scene Linking
# ----------------------------------------------------------------------------
# For the Lunatics who would love to add in their own categories and/or windows
# without worrying about breaking the script, the following hash will give you
# a simplified way of doing just that.
#===============================================================================

module YEZ
module STATUS

# The following hash governs the imported data used. Adjust the data
# properly to meet the demands of the hash.
# method - This is the key used to place at the top.
# switch - If it uses a switch, place the ID. If it doesn't set to nil.
# title - The title used for the command window.
# icon - The icon used for the command window.
# window - Window name used. Type it out fully.
# scene - The scene's class name.
IMPORTED_COMMANDS ={
# :method => [Switch, "Title", Icon, Window, Scene's Name]
:class => [ 67, "Class", 131, nil, "Scene_Class_Change"],
:learn => [ 68, "Learn", 133, nil, "Scene_Learn_Skill"],
:slots => [ 69, "Slots", 103, nil, "Scene_Equip_Skill"],
} # Do not remove this.

end # STATUS
end # YEZ

#===============================================================================
# Editting anything past this point may potentially result in causing computer
# damage, incontinence, explosion of user's head, coma, death, and/or halitosis.
# Therefore, edit at your own risk.
#===============================================================================

module YEZ::STATUS
module_function
#--------------------------------------------------------------------------
# convert_integer_array
#--------------------------------------------------------------------------
def convert_integer_array(array)
result = []
array.each { |i|
case i
when Range; result |= i.to_a
when Integer; result |= [i]
end }
return result
end
#--------------------------------------------------------------------------
# converted arrays
#--------------------------------------------------------------------------
AFFINITIES[:states_shown] = convert_integer_array(AFFINITIES[:states_shown])
AFFINITIES[:elements_shown] = convert_integer_array(AFFINITIES[:elements_shown])
end # YEZ::STATUS

module Vocab
def self.hit; return "HIT"; end
def self.eva; return "EVA"; end
def self.cri; return "CRI"; end
def self.odds;return "AGR"; end
end # Vocab

#===============================================================================
# Scene_Status
#===============================================================================

class Scene_Status < Scene_Base

#--------------------------------------------------------------------------
# overwrite method: start
#--------------------------------------------------------------------------
def start
super
$game_temp.status_index = 0 if $game_temp.status_index == nil
@actor = $game_party.members[@actor_index]
@command_window = Window_Status_Command.new(@actor)
@actor_window = Window_Status_Actor.new(@actor)
@dummy_window = Window_Base.new(0, 128, 544, 288)
create_menu_background
create_mini_windows
$game_party.last_actor_index = @actor_index
end

#--------------------------------------------------------------------------
# overwrite method: create_menu_background
#--------------------------------------------------------------------------
def create_menu_background
if YEZ::STATUS::USE_BG_IMAGE
@menuback_sprite = Sprite.new
@menuback_sprite.bitmap = Cache.system(YEZ::STATUS::BG_FILE_NAME)
@command_window.opacity = 0
@actor_window.opacity = 0
@dummy_window.opacity = 0
update_menu_background
else
super
end
end

#--------------------------------------------------------------------------
# overwrite method: terminate
#--------------------------------------------------------------------------
def terminate
super
dispose_menu_background
dispose_mini_windows
@command_window.dispose
@actor_window.dispose
@dummy_window.dispose
end

#--------------------------------------------------------------------------
# alias method: return_scene
#--------------------------------------------------------------------------
alias return_scene_status_scm return_scene unless $@
def return_scene
$game_temp.status_oy = nil
$game_temp.status_index = nil
$game_temp.status_calc_width = nil
return_scene_status_scm
end

#--------------------------------------------------------------------------
# overwrite method: update
#--------------------------------------------------------------------------
def update
update_menu_background
update_mini_windows if $game_temp.status_index != @command_window.index
@command_window.update
if Input.trigger?(Input::C)
determine_scene_change
elsif Input.trigger?(Input::B)
Sound.play_cancel
return_scene
elsif Input.repeat?(Input::RIGHT)
Sound.play_cursor
$game_temp.status_oy = @command_window.oy
next_actor
elsif Input.repeat?(Input::LEFT)
Sound.play_cursor
$game_temp.status_oy = @command_window.oy
prev_actor
end
super
end

#--------------------------------------------------------------------------
# new method: create_mini_windows
#--------------------------------------------------------------------------
def create_mini_windows
@mini_windows = {}; n = 0
for command in YEZ::STATUS::COMMANDS
case command
#--- Defaults ---
when :parameters
@parameter_window = Window_Status_Parameter.new(@actor)
@mini_windows[n] = @parameter_window
when :affinities
@affinity_window = Window_Status_Affinity.new(@actor)
@mini_windows[n] = @affinity_window
when :skills
@skill_window = Window_Status_Skill.new(@actor)
@mini_windows[n] = @skill_window
when :equips
@equip_window = Window_Status_Equips.new(@actor)
@mini_windows[n] = @equip_window
when :biography
@biography_window = Window_Status_Biography.new(@actor)
@mini_windows[n] = @biography_window
#--- Imports ---
when :formations
next unless $imported["FormationMacros"]
next unless $game_switches[YEZ::MACRO::ENABLE_SWITCH]
@formation_window = Window_Formation.new(@actor)
@formation_window.opacity = 0
@mini_windows[n] = @formation_window
when :mastery
next unless $imported["WeaponMasterySkills"]
@mastery_window = Window_Mastery.new(0, 128, @actor, true)
@mastery_window.opacity = 0
@mini_windows[n] = @mastery_window

else
return_check = true
for key in YEZ::STATUS::IMPORTED_COMMANDS
if key[0] == command
return_check = false
found_key = key[0]
end
end
next if return_check
command_array = YEZ::STATUS::IMPORTED_COMMANDS[found_key]
if command_array[0] != nil
next unless $game_switches[command_array[0]]
end
if command_array[3] != nil
window = eval(command_array[3])
window.x = 0
window.y = 128
window.width = 544
window.height = 288
window.create_contents
window.refresh
else
window = Window_Base.new(0, 128, 544, 288)

end
window.opacity = 0
@mini_windows[n] = window

end
n += 1
end
update_mini_windows
end

#--------------------------------------------------------------------------
# new method: update_mini_windows
#--------------------------------------------------------------------------
def update_mini_windows
$game_temp.status_index = @command_window.index
for i in 0..(@mini_windows.size-1)
@mini_windows[i].visible = false
end
return unless @mini_windows.include?($game_temp.status_index)
@mini_windows[$game_temp.status_index].visible = true
end

#--------------------------------------------------------------------------
# new method: dispose_mini_windows
#--------------------------------------------------------------------------
def dispose_mini_windows
for i in 0..(@mini_windows.size-1)
@mini_windows[i].dispose
@mini_windows[i] = nil
end
end

#--------------------------------------------------------------------------
# new method: determine_scene_change
#--------------------------------------------------------------------------
def determine_scene_change
case @command_window.item
when :parameters
return unless $imported["DistributeParameter"]
Sound.play_decision
$scene = Scene_DistributeParameter.new(@actor.index)
when :skills
Sound.play_decision
$scene = Scene_Skill.new(@actor.index)
when :equips
Sound.play_decision
$scene = Scene_Equip.new(@actor.index)
when :formations
return unless $imported["FormationMacros"]
return unless $game_switches[YEZ::MACRO::ENABLE_SWITCH]
Sound.play_decision
$scene = Scene_Formation.new(@actor.index)
when :mastery
return unless $imported["WeaponMasterySkills"]
Sound.play_decision
$scene = Scene_Mastery.new(@actor.index)

else
return unless YEZ::STATUS::IMPORTED_COMMANDS.include?(@command_window.item)
command_array = YEZ::STATUS::IMPORTED_COMMANDS[@command_window.item]
if command_array[4] != nil
Sound.play_decision
$scene = eval(command_array[4] + ".new(@actor_index)")
end

end
end

end # Scene_Status

#===============================================================================
# Scene_Skill
#===============================================================================

class Scene_Skill < Scene_Base

#--------------------------------------------------------------------------
# alias method: return_scene
#--------------------------------------------------------------------------
alias return_scene_skill_scm return_scene unless $@
def return_scene
if $game_temp.status_index != nil
$scene = Scene_Status.new(@actor_index)
else
return_scene_skill_scm
end
end

end # Scene_Skill

#===============================================================================
# Scene_Equip
#===============================================================================

class Scene_Equip < Scene_Base

#--------------------------------------------------------------------------
# alias method: return_scene
#--------------------------------------------------------------------------
alias return_scene_equip_scm return_scene unless $@
def return_scene
if $game_temp.status_index != nil
$scene = Scene_Status.new(@actor_index)
else
return_scene_equip_scm
end
end

end # Scene_Skill

#===============================================================================
# Game_Temp
#===============================================================================

class Game_Temp

#--------------------------------------------------------------------------
# public instance variables
#--------------------------------------------------------------------------
attr_accessor :status_index
attr_accessor :status_oy
attr_accessor :status_calc_width
attr_accessor :status_ele_width
attr_accessor :status_st_width

end # Game_Temp

#===============================================================================
# Game_Actor
#===============================================================================

class Game_Actor < Game_Battler

#--------------------------------------------------------------------------
# new method: now_exp
#--------------------------------------------------------------------------
def now_exp
return @exp - @exp_list[@level]
end

#--------------------------------------------------------------------------
# new method: next_exp
#--------------------------------------------------------------------------
def next_exp
return @exp_list[@level+1] > 0 ? @exp_list[@level+1] - @exp_list[@level] : 0
end

end # Game_Actor

#===============================================================================
# Window_Status_Actor
#===============================================================================

class Window_Status_Actor < Window_Base

#--------------------------------------------------------------------------
# initialize
#--------------------------------------------------------------------------
def initialize(actor)
super(160, 0, 384, 128)
@actor = actor
refresh
end

#--------------------------------------------------------------------------
# refresh
#--------------------------------------------------------------------------
def refresh
self.contents.clear
draw_actor_face(@actor, 0, 0, size = 96)
x = 104
y = 0
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_stun_indicator(x, y + WLH * 3, @actor) if $imported["ClassStatDUR"]
draw_actor_hp(@actor, x + 120, y + WLH * 1, 120)
draw_actor_mp(@actor, x + 120, y + WLH * 2, 120)
draw_actor_exp(@actor, x + 120, y + WLH * 3, 120)
end

#--------------------------------------------------------------------------
# draw_actor_exp
#--------------------------------------------------------------------------
def draw_actor_exp(actor, x, y, size = 120)
if actor.next_exp != 0
gw = size * actor.now_exp
gw /= actor.next_exp
else
gw = size
end
gc1 = text_color(YEZ::STATUS::EXP_GAUGE_1)
gc2 = text_color(YEZ::STATUS::EXP_GAUGE_2)
self.contents.fill_rect(x, y + WLH - 8, size, 6, gauge_back_color)
self.contents.gradient_fill_rect(x, y + WLH - 8, gw, 6, gc1, gc2)
self.contents.font.color = system_color
self.contents.draw_text(x, y, 40, WLH, YEZ::STATUS::EXP_TEXT)
self.contents.font.color = normal_color
if actor.next_exp != 0
expercent = actor.now_exp * 100.000
expercent /= actor.next_exp
else
expercent = 100.000
end
expercent = 100.000 if expercent > 100.000
text = sprintf(YEZ::STATUS::PERCENT_EXP, expercent)
self.contents.draw_text(x, y, size, WLH, text, 2)
end

end # Window_Status_Actor

#===============================================================================
# Window_Status_Parameter
#===============================================================================

class Window_Status_Parameter < Window_Base

#--------------------------------------------------------------------------
# initialize
#--------------------------------------------------------------------------
def initialize(actor)
super(0, 128, 544, 288)
self.opacity = 0
@actor = actor
refresh
end

#--------------------------------------------------------------------------
# refresh
#--------------------------------------------------------------------------
def refresh
self.contents.clear
sw = self.width - 32
self.contents.font.color = system_color
text = YEZ::STATUS::PARAMETERS[:page_title]
self.contents.draw_text(48, 0, sw/2-48, WLH, text, 0)
draw_exp_info(sw/2+24, 0)
dx = 0; dy = WLH
array = YEZ::STATUS::PARAMETERS[:column1_stats]
draw_column(dx, dy, array)
dx = (self.width - 32) / 2
array = YEZ::STATUS::PARAMETERS[:column2_stats]
draw_column(dx-24, dy*4, array)
end

#--------------------------------------------------------------------------
# draw_exp_info
#--------------------------------------------------------------------------
def draw_exp_info(x, y)
s1 = @actor.exp_s
s2 = @actor.next_rest_exp_s
s_next = sprintf(Vocab::ExpNext, Vocab::level)
self.contents.font.color = system_color
self.contents.draw_text(x, y + WLH * 0, 180, WLH, Vocab::ExpTotal)
self.contents.draw_text(x, y + WLH * 2, 180, WLH, s_next)
self.contents.font.color = normal_color
self.contents.draw_text(x, y + WLH * 1, 180, WLH, s1, 2)
self.contents.draw_text(x, y + WLH * 3, 180, WLH, s2, 2)
end

#--------------------------------------------------------------------------
# draw_column
#--------------------------------------------------------------------------
def draw_column(dx, dy, array)
dx += 48
stat_width = calc_width(array)
for item in array
dw = 60
text = ""
stat = ""
icon = 0
case item
when :blank
when :hp
text = Vocab.hp
stat = @actor.maxhp
icon = $imported["Icons"] ? YEZ::ICONS[:hp] : 0
when :mp
text = Vocab.mp
stat = @actor.maxmp
icon = $imported["Icons"] ? YEZ::ICONS[:mp] : 0
when :atk
text = Vocab.atk
stat = @actor.atk
icon = $imported["Icons"] ? YEZ::ICONS[:atk] : 0
when :def
text = Vocab.def
stat = @actor.def
icon = $imported["Icons"] ? YEZ::ICONS[:def] : 0
when :spi
text = Vocab.spi
stat = @actor.spi
icon = $imported["Icons"] ? YEZ::ICONS[:spi] : 0
when :agi
text = Vocab.agi
stat = @actor.agi
icon = $imported["Icons"] ? YEZ::ICONS[:agi] : 0
when :dex
next unless $imported["BattlerStatDEX"]
text = Vocab.dex
stat = @actor.dex
icon = $imported["Icons"] ? YEZ::ICONS[:dex] : 0
when :res
next unless $imported["BattlerStatRES"]
text = Vocab.res
stat = @actor.res
icon = $imported["Icons"] ? YEZ::ICONS[:res] : 0
when :hit
text = Vocab.hit
icon = $imported["Icons"] ? YEZ::ICONS[:hit] : 0
stat = sprintf("%d",[[@actor.hit, 0].max, 99].min)
when :eva
text = Vocab.eva
icon = $imported["Icons"] ? YEZ::ICONS[:eva] : 0
stat = sprintf("%d",[[@actor.eva, 0].max, 99].min)
when :cri
text = Vocab.cri
icon = $imported["Icons"] ? YEZ::ICONS[:cri] : 0
stat = sprintf("%d",[[@actor.cri, 0].max, 99].min)
when :odds
text = Vocab.odds
icon = $imported["Icons"] ? YEZ::ICONS[:odds] : 0
stat = @actor.odds
when :dur
next unless $imported["ClassStatDUR"]
text = Vocab.dur
stat = @actor.max_dur
icon = $imported["Icons"] ? YEZ::ICONS[:dur] : 0
when :luk
next unless $imported["ClassStatLUK"]
text = Vocab.luk
stat = @actor.luk
icon = $imported["Icons"] ? YEZ::ICONS[:luk] : 0

else; next
end
draw_icon(icon, dx, dy)
self.contents.font.color = system_color
self.contents.draw_text(dx + 24, dy, dw, WLH, text, 0)
self.contents.font.color = normal_color
self.contents.draw_text(dx + 84, dy, stat_width, WLH, stat, 2)
dy += WLH
end
end

#--------------------------------------------------------------------------
# calc_width
#--------------------------------------------------------------------------
def calc_width(array)
return $game_temp.status_calc_width if $game_temp.status_calc_width != nil
n = 0
for actor in $game_party.members
for item in array
text = ""
case item
when :hp; text = actor.maxhp
when :mp; text = actor.maxmp
when :atk; text = actor.atk
when :def; text = actor.def
when :spi; text = actor.spi
when :agi; text = actor.agi
when :res; text = actor.res if $imported["BattlerStatRES"]
when :dex; text = actor.dex if $imported["BattlerStatDEX"]
when :hit; text = sprintf("%d%%", [[actor.hit, 0].max, 99].min)
when :eva; text = sprintf("%d%%", [[actor.eva, 0].max, 99].min)
when :cri; text = sprintf("%d%%", [[actor.cri, 0].max, 99].min)
when :dur; text = actor.dur if $imported["ClassStatDUR"]
when :luk; text = actor.luk if $imported["BattlerStatLUK"]
when :odds; text = actor.odds
else; next
end
n = [n, contents.text_size(text).width].max
end
end
$game_temp.status_calc_width = n
return n
end

end # Window_Status_Parameter

#===============================================================================
# Window_Status_Affinity
#===============================================================================

class Window_Status_Affinity < Window_Base

#--------------------------------------------------------------------------
# initialize
#--------------------------------------------------------------------------
def initialize(actor)
super(0, 128, 544, 288)
self.opacity = 0
@actor = actor
refresh
end

#--------------------------------------------------------------------------
# refresh
#--------------------------------------------------------------------------
def refresh
self.contents.clear
draw_elemental_affinity
draw_status_resistances
end

#--------------------------------------------------------------------------
# draw_elemental_affinity
#--------------------------------------------------------------------------
def draw_elemental_affinity
self.contents.font.size = Font.default_size
affinities = YEZ::STATUS::AFFINITIES
dx = 48; dy = 0; sw = self.width-32
if affinities[:elements_shown].size < 10
self.contents.font.color = system_color
text = affinities[:elements_title]
self.contents.draw_text(dx, dy, sw/2-24, WLH, text, 0)
dy += WLH
end
dw = calc_ele_width(affinities[:elements_shown])
for ele_id in affinities[:elements_shown]
next if ele_id > $data_system.elements.size
draw_icon(affinities[:element_icons][ele_id], dx, dy)
name = $data_system.elements[ele_id]
self.contents.font.color = normal_color
self.contents.font.size = Font.default_size
self.contents.draw_text(dx+24, dy, dw+10, WLH, name, 0)
self.contents.font.color = affinity_colour(@actor.element_rate(ele_id))
self.contents.font.size = affinities[:rank_size]
self.contents.draw_text(dx+34+dw, dy, 60, WLH, element_rate(ele_id), 2)
if @actor.element_rate(ele_id) < 0
self.contents.draw_text(dx+94+dw, dy, 60, WLH, affinities[:absorb])
end
dy += WLH
end
end

#--------------------------------------------------------------------------
# draw_status_resistances
#--------------------------------------------------------------------------
def draw_status_resistances
self.contents.font.size = Font.default_size
affinities = YEZ::STATUS::AFFINITIES
dx = (self.width - 32)/2 + 24; dy = 0; sw = self.width-32
if affinities[:states_shown].size < 10
self.contents.font.color = system_color
text = affinities[:states_title]
self.contents.draw_text(dx, dy, sw/2-24, WLH, text, 0)
dy += WLH
end
dw = calc_state_width(affinities[:states_shown])
for state_id in affinities[:states_shown]
state = $data_states[state_id]
next if state == nil
draw_icon(state.icon_index, dx, dy)
self.contents.font.color = normal_color
self.contents.font.size = Font.default_size
self.contents.draw_text(dx+24, dy, dw+20, WLH, state.name, 0)
self.contents.font.color = rank_colour(@actor.state_probability(state_id))
resist = sprintf("%d%%", @actor.state_probability(state_id))
self.contents.font.size = affinities[:rank_size]
self.contents.draw_text(dx+44+dw, dy, 60, WLH, resist, 2)
dy += WLH
end
end

#--------------------------------------------------------------------------
# calc_ele_width
#--------------------------------------------------------------------------
def calc_ele_width(elements)
return $game_temp.status_ele_width if $game_temp.status_ele_width != nil
n = 0
for ele_id in elements
next if ele_id > $data_system.elements.size
text = $data_system.elements[ele_id]
n = [n, contents.text_size(text).width].max
end
$game_temp.status_ele_width = n
return n
end

#--------------------------------------------------------------------------
# calc_state_width
#--------------------------------------------------------------------------
def calc_state_width(states)
return $game_temp.status_st_width if $game_temp.status_st_width != nil
n = 0
for state_id in states
state = $data_states[state_id]
next if state == nil
text = state.name
n = [n, contents.text_size(text).width].max
end
$game_temp.status_st_width = n
return n
end

#--------------------------------------------------------------------------
# affinity_colour
#--------------------------------------------------------------------------
def affinity_colour(amount)
if amount > 200; n = YEZ::STATUS::AFFINITIES[:rank_colour][:srank]
elsif amount > 150; n = YEZ::STATUS::AFFINITIES[:rank_colour][:arank]
elsif amount > 100; n = YEZ::STATUS::AFFINITIES[:rank_colour][:brank]
elsif amount > 50; n = YEZ::STATUS::AFFINITIES[:rank_colour][:crank]
elsif amount > 0; n = YEZ::STATUS::AFFINITIES[:rank_colour][:drank]
elsif amount == 0; n = YEZ::STATUS::AFFINITIES[:rank_colour][:erank]
else; n = YEZ::STATUS::AFFINITIES[:rank_colour][:frank]
end
return text_color(n)
end

#--------------------------------------------------------------------------
# rank_colour
#--------------------------------------------------------------------------
def rank_colour(amount)
if amount > 100; n = YEZ::STATUS::AFFINITIES[:rank_colour][:srank]
elsif amount > 80; n = YEZ::STATUS::AFFINITIES[:rank_colour][:arank]
elsif amount > 60; n = YEZ::STATUS::AFFINITIES[:rank_colour][:brank]
elsif amount > 40; n = YEZ::STATUS::AFFINITIES[:rank_colour][:crank]
elsif amount > 20; n = YEZ::STATUS::AFFINITIES[:rank_colour][:drank]
elsif amount > 0; n = YEZ::STATUS::AFFINITIES[:rank_colour][:erank]
else; n = YEZ::STATUS::AFFINITIES[:rank_colour][:frank]
end
return text_color(n)
end

#--------------------------------------------------------------------------
# element_rate
#--------------------------------------------------------------------------
def element_rate(ele_id)
rate = @actor.element_rate(ele_id)
if rate >= 0; text = sprintf("%+d%%", rate -100)
elsif rate < 0; text = sprintf("%d%%", -rate)
end
return text
end

end # Window_Status_Affinity

#===============================================================================
# Window_Status_Skill
#===============================================================================

class Window_Status_Skill < Window_Skill

#--------------------------------------------------------------------------
# initialize
#--------------------------------------------------------------------------
def initialize(actor)
$game_temp.in_battle = true if YEZ::STATUS::SKILLS[:battle_only]
super(0, 128, 544, 288, actor)
self.opacity = 0
self.index = -1
$game_temp.in_battle = false if YEZ::STATUS::SKILLS[:battle_only]
end

end # Window_Status_Affinity

#===============================================================================
# Window_Status_Equips
#===============================================================================

class Window_Status_Equips < Window_Status_Parameter

#--------------------------------------------------------------------------
# refresh
#--------------------------------------------------------------------------
def refresh
self.contents.clear
draw_equipments(32, 0)
draw_column((self.width-32)/2-24, WLH, YEZ::STATUS::EQUIPS[:param])
end

#--------------------------------------------------------------------------
# draw_equipments
#--------------------------------------------------------------------------
def draw_equipments(x, y)
self.contents.font.color = system_color
self.contents.draw_text(x, y, 120, WLH, YEZ::STATUS::EQUIPS[:page_title])
if $imported["EquipExtension"]
item_number = [@actor.equips.size, @actor.armor_number + 1].min
item_number.times { |i|
draw_item_name(@actor.equips[i], x + 16, y + WLH * (i + 1)) }
else
for i in 0..4
draw_item_name(@actor.equips[i], x + 16, y + WLH * (i + 1))
end
end
end

end # Window_Status_Equips

#===============================================================================
# Window_Status_Biography
#===============================================================================

class Window_Status_Biography < Window_Base

#--------------------------------------------------------------------------
# initialize
#--------------------------------------------------------------------------
def initialize(actor)
super(0, 128, 544, 288)
self.opacity = 0
@actor = actor
refresh
end

#--------------------------------------------------------------------------
# refresh
#--------------------------------------------------------------------------
def refresh
self.contents.clear
if YEZ::STATUS::ACTOR_BIOS.include?(@actor.id)
draw_actor_bio
elsif YEZ::STATUS::CLASS_BIOS.include?(@actor.class_id)
draw_class_bio
end
end

#--------------------------------------------------------------------------
# draw_actor_bio
#--------------------------------------------------------------------------
def draw_actor_bio
self.contents.font.color = normal_color; dy = 0
text = sprintf(YEZ::STATUS::BIOGRAPHY[:actor_bio], @actor.name)
self.contents.draw_text(0, dy, self.width-32, WLH*2, text, 1)
self.contents.font.size = YEZ::STATUS::BIOGRAPHY[:font_size]
text = YEZ::STATUS::ACTOR_BIOS[@actor.id]
txsize = YEZ::STATUS::BIOGRAPHY[:font_size] + 4
nwidth = 544
dx = 48; dy = WLH*2
text.gsub!(/\\V\[([0-9]+)\]/i) { $game_variables[$1.to_i] }
text.gsub!(/\\V\[([0-9]+)\]/i) { $game_variables[$1.to_i] }
text.gsub!(/\\N\[([0-9]+)\]/i) { $game_actors[$1.to_i].name }
lines = text.split(/(?:[|]|\\n)/i)
lines.each_with_index { |l, i|
l.gsub!(/\\__(\[\d+\])/i) { "\\N#{$1}" }
self.contents.draw_text(dx, i * txsize + dy, nwidth, WLH, l, 0)}
end

#--------------------------------------------------------------------------
# draw_class_bio
#--------------------------------------------------------------------------
def draw_class_bio
self.contents.font.color = normal_color; dy = 0
text = sprintf(YEZ::STATUS::BIOGRAPHY[:class_des], @actor.class.name)
self.contents.draw_text(0, dy, self.width-32, WLH*2, text, 1)
self.contents.font.size = YEZ::STATUS::BIOGRAPHY[:font_size]
text = YEZ::STATUS::CLASS_BIOS[@actor.class.id]
txsize = YEZ::STATUS::BIOGRAPHY[:font_size] + 4
nwidth = 544
dx = 48; dy = WLH*2
text.gsub!(/\\V\[([0-9]+)\]/i) { $game_variables[$1.to_i] }
text.gsub!(/\\V\[([0-9]+)\]/i) { $game_variables[$1.to_i] }
text.gsub!(/\\N\[([0-9]+)\]/i) { $game_actors[$1.to_i].name }
lines = text.split(/(?:[|]|\\n)/i)
lines.each_with_index { |l, i|
l.gsub!(/\\__(\[\d+\])/i) { "\\N#{$1}" }
self.contents.draw_text(dx, i * txsize + dy, nwidth, WLH, l, 0)}
end

end # Window_Status_Biography

#===============================================================================
# Window_Status_Command
#===============================================================================

class Window_Status_Command < Window_Command

#--------------------------------------------------------------------------
# initialize
#--------------------------------------------------------------------------
def initialize(actor)
@actor = actor
create_command_list
super(160, @commands)
self.height = 128
self.oy = $game_temp.status_oy if $game_temp.status_oy != nil
self.index = $game_temp.status_index if $game_temp.status_index != nil
if $game_temp.status_index != nil and $game_temp.status_index > (@commands.size-1)
self.index = @commands.size-1
end
end

#--------------------------------------------------------------------------
# create_command_list
#--------------------------------------------------------------------------
def create_command_list
@commands = []
for command in YEZ::STATUS::COMMANDS
#--- Default Commands
case command
when :parameters; @commands.push(command)
when :affinities; @commands.push(command)
when :skills; @commands.push(command)
when :equips; @commands.push(command)
when :biography
if !YEZ::STATUS::ACTOR_BIOS.include?(@actor.id)
next if !YEZ::STATUS::CLASS_BIOS.include?(@actor.class_id)
end
@commands.push(command)
#--- Imported Commands
when :formations
next unless $imported["FormationMacros"]
next unless $game_switches[YEZ::MACRO::ENABLE_SWITCH]
@commands.push(command)
when :mastery
next unless $imported["WeaponMasterySkills"]
@commands.push(command)

else
next unless YEZ::STATUS::IMPORTED_COMMANDS.include?(command)
if YEZ::STATUS::IMPORTED_COMMANDS[command][0] != nil
next unless $game_switches[YEZ::STATUS::IMPORTED_COMMANDS[command][0]]
end
@commands.push(command)
end
#---
end
end

#--------------------------------------------------------------------------
# item
#--------------------------------------------------------------------------
def item; return @commands[index]; end

#--------------------------------------------------------------------------
# draw_item
#--------------------------------------------------------------------------
def draw_item(index, enabled = true)
rect = item_rect(index)
rect.x += 4
rect.width -= 8
self.contents.clear_rect(rect)
self.contents.font.color = normal_color
self.contents.font.color.alpha = enabled ? 255 : 128
#--- Default ---
case @commands[index]
when :parameters
text = YEZ::STATUS::PARAMETERS[:title]
icon = YEZ::STATUS::PARAMETERS[:icon]
when :affinities
text = YEZ::STATUS::AFFINITIES[:title]
icon = YEZ::STATUS::AFFINITIES[:icon]
when :skills
text = YEZ::STATUS::SKILLS[:title]
icon = YEZ::STATUS::SKILLS[:icon]
when :equips
text = YEZ::STATUS::EQUIPS[:title]
icon = YEZ::STATUS::EQUIPS[:icon]
when :biography
text = YEZ::STATUS::BIOGRAPHY[:title]
icon = YEZ::STATUS::BIOGRAPHY[:icon]
#--- Imported ---
when :formations
return unless $imported["FormationMacros"]
return unless $game_switches[YEZ::MACRO::ENABLE_SWITCH]
text = YEZ::MACRO::TITLE
icon = YEZ::MACRO::ICON
when :mastery
return unless $imported["WeaponMasterySkills"]
text = YEZ::WEAPON_MASTERY::TITLE
icon = YEZ::WEAPON_MASTERY::ICON

else
return unless YEZ::STATUS::IMPORTED_COMMANDS.include?(@commands[index])
text = YEZ::STATUS::IMPORTED_COMMANDS[@commands[index]][1]
icon = YEZ::STATUS::IMPORTED_COMMANDS[@commands[index]][2]

end
#---
align = 1
if YEZ::STATUS::USE_ICONS
rect.x += 24
rect.width -= 24
align = 0
end
self.contents.draw_text(rect, text, align)
return unless YEZ::STATUS::USE_ICONS
draw_icon(icon, rect.x-24, rect.y)
end

end # Window_Status_Command

#===============================================================================
#
# END OF FILE
#
#===============================================================================[/code]

Code:

#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_
#_/  ◆    Attribute Point Stat Distribution - KGC_DistributeParameter  ◆ VX ◆
#_/  ◇                      Last Update: 2008/09/13                          ◇
#_/  ◆                    Translation by Mr. Anonymous                      ◆
#_/  ◆                  Extended Annotation by Touchfuzzy                    ◆
#_/  ◆            Extended Updates by MrAnonymous & Touchfuzzy              ◆
#_/  ◆ KGC Site:                                                            ◆
#_/  ◆ http://f44.aaa.livedoor.jp/~ytomy/                                    ◆
#_/  ◆ Translator's Blog:                                                    ◆
#_/  ◆ http://mraprojects.wordpress.com                                      ◆
#_/-----------------------------------------------------------------------------
#_/  This script gives you the ability to completely change the way actors'
#_/ attributes are gained. This system allows for the player to distribute stat
#_/ points to actors which are gained upon level up.
#_/=============================================================================
#_/                      ◆ script Commands ◆
#_/  These commands are used in "script" function in the third page of event
#_/  commands under "Advanced".
#_/
#_/ * gain_rp(ActorID, Value)
#_/    Increases the MaxRP of a given actor.
#_/
#_/ * reset_distributed_count(ActorID)
#_/    Resets the distributed RP of a given actor.
#_/
#_/ * call_distribute_parameter(ActorID)
#_/    Calls the Distribute Parameter screen for a given actor.
#_/
#_/=============================================================================
#_/ Install: Insert below KGC_ExtendedEquipScene and KGC_CustomMenuCommand.
#_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_/_

#==============================================================================#
#                          ★ Customization ★                                  #
#==============================================================================#

module KGC
  module DistributeParameter
  #                      ◆ Distribution Tables ◆
  # Here you may customize the costs and increase rates of specific parameters.
  # The order in which these costs and increase rates are set are as follows:
  #                    [IPC, IPSG, MAP, PCI, PSGI]
  #                                Key:
  # IPC = Initial Point Cost. This is how many AP it cost to buy the first
  #      point of this parameter.
  #
  # IPSG = Initial Point Stat Growth. This is how much the stat will go up with
  #        the first point of this parameter.
  #                                           
  # MAP = Maximum Attribute Points. The maximum amount of AP that can be spent
  #      on this stat.  You may also put a level based equation in this but
  #      remember that if you put in an equation it is IMPORTANT that you put
  #      quotation marks ("") around it and to use level in all lower case.
  #      Example: "level"
  #
  # PCI = Point Cost Increase.  For every AP spent in this parameter the cost
  #      of this parameter increases by this amount.
  #
  # PSGI = Point Stat Growth Increase.  For every AP spent in this parameter
  #        the number of points you gain in the stat increases by this much.
  #
  #  Also, if you completely remove a line (e.g. ":hit => [1, 1, 20, 0.7],")
  #  it will remove it from the distribution screen altogether.
  #  Very useful if your project doesn't require a specific stat.
  GAIN_PARAMETER = {
  # Parameter      IPC, IPSG,  MAP,  PCI,  PSGI
    :maxhp      => [1,  10,  999,  0,],  # Maximum HP
    :maxmp      => [1,    5,  999,  0],  # Maximum MP
    :atk        => [1,    1,  999,  0],  # Attack
    :def        => [1,    1,  999,  0],  # Defense
    :spi        => [1,    1,  999,  0],  # Spirit
    :res        => [1,    1, 999, 0], # Res
    :agi        => [1,    1,  999,  0],  # Agility
    :eva        => [1,    1,  50,  0],        # Evasion
    :cri        => [1,    1,  50,  0],        # Critical
    :hit        => [1,    1,  50,  0],        # Evasion
    :odds        => [1,    1, 20,  0],          # Luck (Chance of being targetted)
  #                        ◆ AP Gain Rate ◆
  # Added by Touchfuzzy.
  #  I added this in to the GAIN_PARAMETER tables so that you can use seperate
  #  equations for different characters and classes.
  #  This is the equation that determines your total AP gained every level.
  #  (Character Level to the 0.25th power + 2) * Level
  #  This causes you to start at 3 points per level and increase slightly over
  #  time.
  #  As an example if you wish to gain a static 3 points per level write it as
  #  :maxrpexp = "level * 3" 
    :maxrpexp    => ["(level ** 0 + 4.0) * level"],  # Max AP
  }  # <- Do not remove!

  #              ◆ Individual Actor Gain Parameter Tables ◆
  #  You may choose to manually specify an individual actor's gain parameters.
  #  To do so, use the same format as above GAIN_PARAMETER table but instead
  #  use PERSONAL_GAIN_PARAMETER [n] (Where n = Actor ID)
  #  Any parameter you do not set in this table will instead draw from the
  #  GAIN_PARAMETER chart.
  #
  #  Example:
  # PERSONAL_GAIN_PARAMETER[1] = {
  # :maxhp => [2, 20, 50, 0.5,  5], 
  # :maxmp => [1, 10, 30, 0.3, 0.5],
  # :atk  => [1,  1, 30, 0.3, 0.5],
  # :def  => [1,  2, 30, 0.4, 0.5],
  # :spi  => [1,  2, 50, 0.5, 0.8],
  # :agi  => [1,  2, 30, 0.4, 0.6],
  # :hit  => [1,  1, 20, 0.7],   
  # :eva  => [1,  1, 20, 0.7],   
  # :cri  => [1,  1, 20, 0.7],
  # :skill_speed => [1,  1, 20, 0.5], 
  # :item_speed  => [1,  1, 20, 0.5],   
  # :odds        => [1,  1, 5],         
  # :maxrpexp => ["(level ** 0.25 + 2.0) * level"]
  # }
  PERSONAL_GAIN_PARAMETER = []
  #            ★ Insert Custom Actor Gain Tables Below Here ★

 
 
 
  #            ★ Insert Custom Actor Gain Tables Above Here ★

  #              ◆ Class-Specific Gain Parameter Tables ◆
  #  You may choose to manually specify an entire class's gain parameters.
  #  To do so, use the same format as above GAIN_PARAMETER table but instead
  #  use CLASS_GAIN_PARAMETER [n] (Where n = Number of class in the database)
  #  Any parameter you do not set in this table will instead draw from the
  #  GAIN_PARAMETER chart. Also note that class gain parameters take the highest
  #  priority.
  CLASS_GAIN_PARAMETER = []
  #            ★ Insert Custom Class Gain Tables Below Here ★

 
 
 
  #            ★ Insert Custom Class Gain Tables Above Here ★

  # ◆ AP = Attribute Points. These settings are for the AP Distrubution Screen.
  #  VOCAB_RP appears at the top of the column which lists the AP cost of
  #  the parameter
  VOCAB_RP  = "Coût"
  # VOCAB_RP_A appears next to where it lists your current and total AP.
  VOCAB_RP_A = "PC"

  #                    ◆ Parameter Labels ◆
  #  Allows you to change the text of Hit Ratio, Evasion, Critical, Skill
  #  Speed, Item Speed, and Odds (luck) on the distribution screen.
  VOCAB_PARAM = {
    :hit        => "Précision",  # Hit Ratio (Accuracy)
    :eva        => "Esquive",  # Evasion
    :cri        => "Critique",  # Critical
    :res => "Esprit",
    :skill_speed => "Vitesse Magie",  # Skill Speed
    :item_speed  => "Vitesse Objets",  # Item Speed
    :odds        => "Chance",  # Odds (Luck)
  }  # <- Do not remove!
 
 
    # This is all of the icon information for the first page.
      ICON_MAXHP = 142  # If a stat is higher than base stat.
      ICON_MAXMP  = 143  # If a stat is lower than base stat.
      ICON_ATK  = 11603    # Icon for ATK
      ICON_DEF  = 11604    # Icon for DEF
      ICON_SPI  = 11605    # Icon for SPI
      ICON_AGI  = 11607    # Icon for AGI
      ICON_RES  = 11606  # Icon for HIT
      ICON_EVA  = 11610  # Icon for EVA
      ICON_CRI  = 11611  # Icon for CRI
      ICON_ODDS = 11613  # Icon for ODD

  #                      ◆ Caption Text ◆
  # These fields affect the text at the top of the distribution screen.
  # Attribute name label.
  AT_CAPTION = "Caractéristique"
  # AP cost/rate label.
  RT_CAPTION = "Bonus"
  # Current AP ppent on given attribute label.
  SP_CAPTION = "Total"
  # Current status (right window) label.
  CS_CAPTION = "Statut Actuel"
 
  #                      ◆ Help Window Text ◆
  #  Text of the menu title for the AP Distribution Screen.
  DISTRIBUTE_SCENE_CAPTION = "Caractéristiques - Appuyez sur <Q> ou <W> pour changer de Personnage"
 
  #                      ◆ AP Gauge Colors ◆
  #  Allows you to change the color of the guages that appear under the stats
  #  side bar. The color can also be determined by a numerical expression.
  #  Example: GAUGE_START_COLOR = Color.new(255, 0, 0)  <- This is red.
  #  This is the fill color for the early phase of the guage.
  GAUGE_START_COLOR = 28
  #  This is the fill color for the late phase of the guage. (When full)
  GAUGE_END_COLOR  = 29

  #                  ◆ Menu Command Button & Text ◆
  #  When USE_MENU_DISTRIBUTE_PARAMETER_COMMAND = true,
  #  the AP Distribution System is added to the menu under "Quit Game".
  #  When false, it does not. (Obviously)
  USE_MENU_DISTRIBUTE_PARAMETER_COMMAND = false
  #  Allows you to change the text for this button on the main command menu.
  VOCAB_MENU_DISTRIBUTE_PARAMETER      = "Aptitude"

  #                  ◆ Parameter Re-distribution ◆
  #  This affects whether the player can delevel the parameters that have
  #  been increased.
  #  true  : Allows the player to reassign AP.
  #  false : Prevents the player from unassigning AP if set to false.
  ENABLE_REVERSE_DISTRIBUTE = false
 
  #                    ◆ AP in Status Window ◆
  # Added by Mr. Anonymous.
  #  This toggle allows you to enable/disable the AP display on the status
  #  screen.
  SHOW_STATUS_RP = true
  #  This toggle allows you to adjust the position of the AP display on the
  #  status screen. (If SHOW_STATUS_RP = true)
  #  0. Below Actor's Face Image
  #  1. Below Actor's Parameters
  SHOW_STATUS_RP_POS = 1
 
  #  Pour activé ou désactivé les Icons dans le menu
  USE_ICONS = true
 
  #                ◆ Extra Parameters in Status Window ◆
  # Added by Mr. Anonymous.
  #  This toggle allows you to enable/disable the parameters for accuracy,
  #  evasion, and critical below the regular paramaters (STR, DEF, SPI, AGI)
  SHOW_STATUS_EX_PARAMS = true
 
  #        ◆ Call DistributeParameter From Actor Status Window ◆
  # Added by Mr. Anonymous.
  #  This allows you to change what key/button is pressed on the status window
  #  to shift to the DistributeParameter window.
  #  When set to nil, this is disabled. ( CALL_DISTPARAMKEY = Input::nil )
  CALL_DISTPARAMKEY = Input::CTRL  # On the keyboard, button X is the A key.
 
  #                      ◆ Show Actor Graphic ◆
  # Added by Mr. Anonymous.
  #  This toggle allows you to enable/disable the actor sprite in the Distribute
  #  Parameter window next to the actor name.
  #  true = Show the sprite.
  #  false = Do not show.
  SHOW_SPRITE = false
end
end

#=============================================================================#
#                          ★ End Customization ★                              #
#=============================================================================#

#=================================================#
#                    IMPORT                      #
#=================================================#

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

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

module KGC::DistributeParameter
  # Set up parameter array
  PARAMS = [:maxhp, :maxmp, :atk, :def, :spi, :res, :agi, :hit, :eva, :cri,
    :skill_speed, :odds]
end

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

#==============================================================================
# ■ Vocab
#==============================================================================

module Vocab
  def self.res 
    return KGC::DistributeParameter::VOCAB_PARAM[:res]
    icon = KGC::DistributeParameter::ICON_RES
    return $data_system.terms.res    # Added 4/1/08
  end
 
  def self.hit
    return KGC::DistributeParameter::VOCAB_PARAM[:hit]
    return $data_system.terms.hit    # Added 4/1/08
  end

  def self.eva
    return KGC::DistributeParameter::VOCAB_PARAM[:eva]
    return $data_system.terms.eva    # Added 4/1/08
  end

  def self.cri
    return KGC::DistributeParameter::VOCAB_PARAM[:cri]
    return $data_system.terms.cri    # Added 4/1/08
  end

  def self.skill_speed
    return KGC::DistributeParameter::VOCAB_PARAM[:skill_speed]
    return $data_system.terms.skill_speed    # Added 9/14/08
  end

  def self.item_speed
    return KGC::DistributeParameter::VOCAB_PARAM[:item_speed]
  end

  def self.odds
    return KGC::DistributeParameter::VOCAB_PARAM[:odds]
    return $data_system.terms.odds    # Added 9/14/08
  end

  def self.rp
    return KGC::DistributeParameter::VOCAB_RP
  end

  def self.rp_a
    return KGC::DistributeParameter::VOCAB_RP_A
  end

  def self.distribute_parameter
    return KGC::DistributeParameter::VOCAB_MENU_DISTRIBUTE_PARAMETER
  end
end

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

#==============================================================================
# □ KGC::Commands
#==============================================================================

module KGC
module Commands
  module_function
  #--------------------------------------------------------------------------
  # ○ パラメータ振り分けに関する値をチェック
  #--------------------------------------------------------------------------
  def check_distribution_values
    (1...$data_actors.size).each { |i|
      actor = $game_actors[i]
      actor.check_distribution_values
      actor.restore_distribution_values
    }
  end
  #--------------------------------------------------------------------------
  # ○ RP の増減
  #    actor_id : アクター ID
  #    value    : 増減量
  #--------------------------------------------------------------------------
  def gain_rp(actor_id, value)
    actor = $game_actors[actor_id]
    return if actor == nil
    actor.gain_rp(value)
  end
  #--------------------------------------------------------------------------
  # ○ 振り分け回数をリセット
  #    actor_id : アクター ID
  #--------------------------------------------------------------------------
  def reset_distributed_count(actor_id)
    actor = $game_actors[actor_id]
    return if actor == nil
    actor.clear_distribution_values
    actor.restore_distribution_values
  end
  #--------------------------------------------------------------------------
  # ○ パラメータ振り分け画面の呼び出し
  #    actor_index : アクターインデックス
  #--------------------------------------------------------------------------
  def call_distribute_parameter(actor_index = 0)
    return if $game_temp.in_battle
    $game_temp.next_scene = :distribute_parameter
    $game_temp.next_scene_actor_index = actor_index
  end
end
end

#=================================================#
#            INCLUDE COMMANDS                    #
#=================================================#
#    Include KGC::Commands in Game_Interpreter    #
#=================================================#

class Game_Interpreter
  include KGC::Commands
end

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

#==============================================================================
# ■ Game_Battler
#==============================================================================

class Game_Battler
  #--------------------------------------------------------------------------
  # ● 能力値に加算する値をクリア
  #--------------------------------------------------------------------------
  alias clear_extra_values_KGC_DistributeParameter clear_extra_values
  def clear_extra_values
    clear_extra_values_KGC_DistributeParameter

    clear_distribution_values
    calc_distribution_values
  end
  #--------------------------------------------------------------------------
  # ○ パラメータ振り分けに関する値をクリア
  #--------------------------------------------------------------------------
  def clear_distribution_values
    @distributed_count = {}
    KGC::DistributeParameter::PARAMS.each { |param|
      @distributed_count[param] = 0
    }
  end
  #--------------------------------------------------------------------------
  # ○ パラメータ振り分けに関する値をチェック
  #--------------------------------------------------------------------------
  def check_distribution_values
    last_distributed_count = @distributed_count

    clear_distribution_values

    @distributed_count = last_distributed_count if last_distributed_count != nil
  end
  #--------------------------------------------------------------------------
  # ○ 各種修正値を計算
  #--------------------------------------------------------------------------
  def calc_distribution_values
    # 継承先で定義
  end
  #--------------------------------------------------------------------------
  # ○ 振り分けによる上昇値を取得
  #    param : パラメータの Symbol
  #--------------------------------------------------------------------------
  def distributed_param(param)
    return 0
  end
end

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

#==============================================================================
# ■ Game_BattleAction
#==============================================================================

class Game_BattleAction
  #--------------------------------------------------------------------------
  # ● 行動スピードの決定
  #--------------------------------------------------------------------------
  alias make_speed_KGC_DistributeParameter make_speed
  def make_speed
    make_speed_KGC_DistributeParameter
    if skill?
      n = [battler.distributed_param(:skill_speed), skill.speed].min
      @speed -= n
    end
    if item?
      n = [battler.distributed_param(:item_speed), item.speed].min
      @speed -= n
    end
  end
end
#=================================================#

#==============================================================================
# ■ Game_Actor
#==============================================================================

class Game_Actor < Game_Battler
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #    actor_id : アクター ID
  #--------------------------------------------------------------------------
  alias initialize_KGC_DistributeParameter initialize
  def initialize(actor_id)
    @actor_id = actor_id
    @class_id = $data_actors[actor_id].class_id

    initialize_KGC_DistributeParameter(actor_id)
  end
  #--------------------------------------------------------------------------
  # ○ パラメータ増加量を取得
  #--------------------------------------------------------------------------
  def gain_parameter_list
    result = KGC::DistributeParameter::GAIN_PARAMETER
    # アクター固有
    list = KGC::DistributeParameter::PERSONAL_GAIN_PARAMETER[self.id]
    result = result.merge(list) if list != nil
    # 職業固有
    list = KGC::DistributeParameter::CLASS_GAIN_PARAMETER[self.class_id]
    result = result.merge(list) if list != nil

    return result
  end
  #--------------------------------------------------------------------------
  # ○ 各種修正値を計算
  #--------------------------------------------------------------------------
  def calc_distribution_values
    @rp_cost = 0
    @distributed_param = {}
    gain_parameter_list.each { |k, v|
      next if v == nil
      cost = 0
      param = 0
      distributed_count(k).times { |i|
        cost_plus  = v[0]
        cost_plus  += v[3] * i if v[3] != nil
        param_plus  = v[1]
        param_plus += v[4] * i if v[4] != nil
        cost  += Integer(cost_plus)
        param += Integer(param_plus)
      }
      @rp_cost += [cost, 0].max
      @distributed_param[k] = param
    }
  end
  #--------------------------------------------------------------------------
  # ○ 各種修正値を修復
  #--------------------------------------------------------------------------
  def restore_distribution_values
    calc_distribution_values
    self.hp = self.hp
    self.mp = self.mp
  end
  #--------------------------------------------------------------------------
  # ○ 振り分けによる上昇値を取得
  #    param : パラメータの Symbol
  #--------------------------------------------------------------------------
  def distributed_param(param)
    return 0 if @distributed_param == nil
    return 0 if @distributed_param[param] == nil
    return @distributed_param[param]
  end
  #--------------------------------------------------------------------------
  # ● 基本 MaxHP の取得
  #--------------------------------------------------------------------------
  alias base_maxhp_KGC_DistributeParameter base_maxhp
  def base_maxhp
    n = base_maxhp_KGC_DistributeParameter + distributed_param(:maxhp)
    return n
  end
  #--------------------------------------------------------------------------
  # ● 基本 MaxMP の取得
  #--------------------------------------------------------------------------
  alias base_maxmp_KGC_DistributeParameter base_maxmp
  def base_maxmp
    n = base_maxmp_KGC_DistributeParameter + distributed_param(:maxmp)
    return n
  end
  #--------------------------------------------------------------------------
  # ● 基本攻撃力の取得
  #--------------------------------------------------------------------------
  alias base_atk_KGC_DistributeParameter base_atk
  def base_atk
    n = base_atk_KGC_DistributeParameter + distributed_param(:atk)
    return n
  end
  #--------------------------------------------------------------------------
  # ● 基本防御力の取得
  #--------------------------------------------------------------------------
  alias base_def_KGC_DistributeParameter base_def
  def base_def
    n = base_def_KGC_DistributeParameter + distributed_param(:def)
    return n
  end
  #--------------------------------------------------------------------------
  # ● 基本精神力の取得
  #--------------------------------------------------------------------------
  alias base_spi_KGC_DistributeParameter base_spi
  def base_spi
    n = base_spi_KGC_DistributeParameter + distributed_param(:spi)
    return n
  end
  #--------------------------------------------------------------------------
  # ● 基本敏捷性の取得
  #--------------------------------------------------------------------------
  alias base_agi_KGC_DistributeParameter base_agi
  def base_agi
    n = base_agi_KGC_DistributeParameter + distributed_param(:agi)
    return n
  end
 
  alias res_KGC_DistributeParameter res
def res
n = res_KGC_DistributeParameter + distributed_param(:res)
return n
end
  #--------------------------------------------------------------------------
  # ● 命中率の取得
  #--------------------------------------------------------------------------
  alias hit_KGC_DistributeParameter hit
  def hit
    n = hit_KGC_DistributeParameter + distributed_param(:hit)
    return n
  end
  #--------------------------------------------------------------------------
  # ● 回避率の取得
  #--------------------------------------------------------------------------
  alias eva_KGC_DistributeParameter eva
  def eva
    n = eva_KGC_DistributeParameter + distributed_param(:eva)
    return n
  end
  #--------------------------------------------------------------------------
  # ● クリティカル率の取得
  #--------------------------------------------------------------------------
  alias cri_KGC_DistributeParameter cri
  def cri
    n = cri_KGC_DistributeParameter + distributed_param(:cri)
    return n
  end
  #--------------------------------------------------------------------------
  # ● 狙われやすさの取得
  #--------------------------------------------------------------------------
  alias odds_KGC_DistributeParameter odds
  def odds
    n = odds_KGC_DistributeParameter + distributed_param(:odds)
    return n
  end
  #--------------------------------------------------------------------------
  # ○ MaxRP の取得 - Method rewritten by Touchfuzzy
  #--------------------------------------------------------------------------
  def maxrp
    gain = gain_parameter_list[:maxrpexp]
    n = Integer(eval(gain[0]))
    return [n + maxrp_plus, 0].max
  end
  #--------------------------------------------------------------------------
  # ○ MaxRP 補正値の取得
  #--------------------------------------------------------------------------
  def maxrp_plus
    @maxrp_plus = 0 if @maxrp_plus == nil
    return @maxrp_plus
  end
  #--------------------------------------------------------------------------
  # ○ RP の取得
  #--------------------------------------------------------------------------
  def rp
    return [maxrp - @rp_cost, 0].max
  end
  #--------------------------------------------------------------------------
  # ○ 振り分け回数の取得
  #    param : 振り分け先パラメータ (Symbol)
  #--------------------------------------------------------------------------
  def distributed_count(param)
    clear_distribution_values if @distributed_count == nil
    @distributed_count[param] = 0 if @distributed_count[param] == nil
    return @distributed_count[param]
  end
  #--------------------------------------------------------------------------
  # ○ RP の増減
  #    value : 増減量
  #--------------------------------------------------------------------------
  def gain_rp(value)
    @maxrp_plus = maxrp_plus + value
  end
  #--------------------------------------------------------------------------
  # ○ 振り分け回数の増減
  #    param : 振り分け先パラメータ (Symbol)
  #    value : 増減量
  #--------------------------------------------------------------------------
  def gain_distributed_count(param, value = 1)
    n = distributed_count(param)
    @distributed_count[param] += value if n.is_a?(Integer)
  end
  #--------------------------------------------------------------------------
  # ○ RP 振り分けによる成長効果適用
  #    param  : 振り分け先パラメータ (Symbol)
  #    reverse : 逆加算のときは true
  #--------------------------------------------------------------------------
  def rp_growth_effect(param, reverse = false)
    gain = gain_parameter_list[param]
    return if gain == nil  # 無効なパラメータ

    if reverse
      return if distributed_count(param) == 0  # 逆加算不可
    else
      return unless can_distribute?(param)
    end

    gain_distributed_count(param, reverse ? -1 : 1)
    restore_distribution_values
  end


Code:

  #--------------------------------------------------------------------------
  # ○ パラメータ振り分け可否判定
  #    param : 振り分け先パラメータ (Symbol)
  #--------------------------------------------------------------------------
  def can_distribute?(param)
    gain = gain_parameter_list[param]
    return false if gain == nil                          # 無効なパラメータ
    return false if self.rp < distribute_cost(param)    # RP 不足
    return false if gain[2] <= distributed_count(param)  # 回数上限

    return true
  end
  #--------------------------------------------------------------------------
  # ○ パラメータ振り分けコスト計算
  #    param : 振り分け先パラメータ (Symbol)
  #--------------------------------------------------------------------------
  def distribute_cost(param)
    gain = gain_parameter_list[param]
    return 0 if gain == nil  # 無効なパラメータ

    n = gain[0]
    if gain[3] != nil
      count = [distributed_count(param), gain[2] - 1].min
      n += gain[3] * count
    end
    return [Integer(n), 0].max
  end
  #--------------------------------------------------------------------------
  # ○ パラメータ振り分け時の増加量計算
  #    param : 振り分け先パラメータ (Symbol)
  #--------------------------------------------------------------------------
  def distribute_gain(param)
    gain = gain_parameter_list[param]
    return 0 if gain == nil  # 無効なパラメータ

    n = gain[1]
    if gain[4] != nil
      count = [distributed_count(param), gain[2] - 1].min
      n += gain[4] * count
    end
    return Integer(n)
  end
end

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

#==============================================================================
# ■ Window_Base
#==============================================================================

class Window_Base < Window
  #--------------------------------------------------------------------------
  # ○ RP の文字色を取得
  #    actor : アクター
  #--------------------------------------------------------------------------
  def rp_color(actor)
    return (actor.rp == 0 ? knockout_color : normal_color)
  end
  #--------------------------------------------------------------------------
  # ○ 振り分けゲージの色 1 の取得
  #--------------------------------------------------------------------------
  def distribute_gauge_color1
    color = KGC::DistributeParameter::GAUGE_START_COLOR
    return (color.is_a?(Integer) ? text_color(color) : color)
  end
  #--------------------------------------------------------------------------
  # ○ 振り分けゲージの色 2 の取得
  #--------------------------------------------------------------------------
  def distribute_gauge_color2
    color = KGC::DistributeParameter::GAUGE_END_COLOR
    return (color.is_a?(Integer) ? text_color(color) : color)
  end
  #--------------------------------------------------------------------------
  # ○ RP の描画
  #    actor : アクター
  #    x    : 描画先 X 座標
  #    y    : 描画先 Y 座標
  #    width : 幅
  #--------------------------------------------------------------------------
  def draw_actor_rp(actor, x, y, width = 120)
    self.contents.font.color = system_color
    self.contents.draw_text(x, y, 40, WLH, Vocab::rp_a)
    self.contents.font.color = rp_color(actor)
    xr = x + width
    if width < 120
      self.contents.draw_text(xr - 40, y, 40, WLH, actor.rp, 2)
    else
      self.contents.draw_text(xr - 90, y, 40, WLH, actor.rp, 2)
      self.contents.font.color = normal_color
      self.contents.draw_text(xr - 50, y, 10, WLH, "/", 2)
      self.contents.draw_text(xr - 40, y, 40, WLH, actor.maxrp, 2)
    end
    self.contents.font.color = normal_color
  end
  #--------------------------------------------------------------------------
  # ○ 振り分けゲージの描画
  #    actor : アクター
  #    param : パラメータ
  #    x    : 描画先 X 座標
  #    y    : 描画先 Y 座標
  #    width : 幅
  #--------------------------------------------------------------------------
  def draw_actor_distribute_gauge(actor, param, x, y, width = 120)
    gain = actor.gain_parameter_list[param]
    return if gain == nil
    gw = width * actor.distributed_count(param) / [gain[2], 1].max
    gc1 = distribute_gauge_color1
    gc2 = distribute_gauge_color2
    self.contents.fill_rect(x, y + WLH - 8, width, 6, gauge_back_color)
    self.contents.gradient_fill_rect(x, y + WLH - 8, gw, 6, gc1, gc2)
  end
  #=============================================================================
  #  Added by Mr. Anonymous ( 4/1/08 )
  # Sets up the initial parameters and the entended/extra parameters.
  #=============================================================================
  if KGC::DistributeParameter::SHOW_STATUS_EX_PARAMS
    alias draw_actor_parameter_KGC_DistributeParameter draw_actor_parameter
    def draw_actor_parameter(actor, x, y, type)
      draw_actor_parameter_KGC_DistributeParameter(actor, x, y, type)
      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::res
parameter_value = actor.res
when 4
parameter_name = Vocab::agi
parameter_value = actor.agi
when 5
parameter_name = Vocab::lck
parameter_value = actor.lck
when 6
parameter_name = Vocab::hit
parameter_value = actor.hit
when 7
parameter_name = Vocab::eva
parameter_value = actor.eva
when 8
parameter_name = Vocab::cri
parameter_value = actor.cri
      end
      self.contents.font.color = system_color
      self.contents.draw_text(x, y, 120, WLH, parameter_name)
      self.contents.font.color = normal_color
      self.contents.draw_text(x + 120, y, 36, WLH, parameter_value, 2)
    end
  end
end

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

#==============================================================================
# ■ Window_Command
#==============================================================================

class Window_Command < Window_Selectable
  unless method_defined?(:add_command)
  #--------------------------------------------------------------------------
  # ○ コマンドを追加
  #    追加した位置を返す
  #--------------------------------------------------------------------------
  def add_command(command)
    @commands << command
    @item_max = @commands.size
    item_index = @item_max - 1
    refresh_command
    draw_item(item_index)
    return item_index
  end
  #--------------------------------------------------------------------------
  # ○ コマンドをリフレッシュ
  #--------------------------------------------------------------------------
  def refresh_command
    buf = self.contents.clone
    self.height = [self.height, row_max * WLH + 32].max
    create_contents
    self.contents.blt(0, 0, buf, buf.rect)
    buf.dispose
  end
  #--------------------------------------------------------------------------
  # ○ コマンドを挿入
  #--------------------------------------------------------------------------
  def insert_command(index, command)
    @commands.insert(index, command)
    @item_max = @commands.size
    refresh_command
    refresh
  end
  #--------------------------------------------------------------------------
  # ○ コマンドを削除
  #--------------------------------------------------------------------------
  def remove_command(command)
    @commands.delete(command)
    @item_max = @commands.size
    refresh
  end
  end
end

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

#==============================================================================
# ■ Window_Status
#==============================================================================
# Added by Mr. Anonymous  ( 4/1/08 )
# Checks SHOW_STATUS_RP's value, if true RP is added to Status Window.
#==============================================================================
if KGC::DistributeParameter::SHOW_STATUS_RP
  class Window_Status < Window_Base
  #--------------------------------------------------------------------------
  # ● Draw RP in Status Window
  #    x : Width X - 128 (beneath actor face)
  #    y : Hight Y (On row + Window_Status Definition)
  #--------------------------------------------------------------------------
    alias draw_basic_info_KGC_DistributeParameter draw_basic_info
    def draw_basic_info(x, y)
      draw_basic_info_KGC_DistributeParameter(x, y)
      # Checks SHOW_STATUS_RP_POS, if 0, RP is shown beneath face of actor.
      if KGC::DistributeParameter::SHOW_STATUS_RP_POS == 0
        draw_actor_rp(@actor, x - 129, y + WLH * 4)
      end
      # If 1, RP is shown under parameters. (Centered)
      if KGC::DistributeParameter::SHOW_STATUS_RP_POS == 1
        draw_actor_rp(@actor, x - 80, y + WLH * 14 - 6)
      end
    end
    #------------------------------------------------------------------------
    # ● Draw Extra (Normally Hidden) Parameters in Status Window
    #    x : Width X - 128 (beneath actor face)
    #    y : Hight Y (On row + Window_Status Definition)
    # Added by Mr. Anonymous  ( 4/1/08 )
    #-------------------------------------------------------------------------
    alias draw_parameters_KCG_DistributeParameter draw_parameters
    def draw_parameters(x, y)
      draw_parameters_KCG_DistributeParameter(x, y)
      if KGC::DistributeParameter::SHOW_STATUS_EX_PARAMS
        draw_actor_parameter(@actor, x, y + WLH * 4, 4)
        draw_actor_parameter(@actor, x, y + WLH * 5, 5)
        draw_actor_parameter(@actor, x, y + WLH * 6, 6)
        draw_actor_parameter(@actor, x, y + WLH * 7, 7)
      end
    end
  end
end

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

#==============================================================================
# □ Window_DistributeParameterActor
#------------------------------------------------------------------------------
#  振り分け画面で、アクターの情報を表示するウィンドウです。
#==============================================================================

class Window_DistributeParameterActor < Window_Base
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #    x    : ウィンドウの X 座標
  #    y    : ウィンドウの Y 座標
  #    actor : アクター
  #--------------------------------------------------------------------------
  def initialize(x, y, actor)
    super(x, y, Graphics.width, WLH + 32)
    @actor = actor
    refresh
  end
  #--------------------------------------------------------------------------
  # ● リフレッシュ
  #--------------------------------------------------------------------------
  def refresh
    self.contents.clear
    draw_actor_name(@actor, 32, 0)
    draw_actor_level(@actor, 264, 0)
    draw_actor_rp(@actor, 372, 0)
    # Include actor class
    # Added by Mr. Anonymous  ( 4/1/08 )
    draw_actor_class(@actor, 152, 0)
    # Method for displaying actor's sprite
    # Added by Mr. Anonymous  ( 4/1/08 )
    if KGC::DistributeParameter::SHOW_SPRITE
      draw_actor_graphic(@actor, 14, 31)
    end
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# □ Window_DistributeParameterList
#------------------------------------------------------------------------------
#  振り分け画面で、成長させるパラメータを選択するウィンドウです。
#==============================================================================

class Window_DistributeParameterList < Window_Selectable
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #    actor : アクター
  #--------------------------------------------------------------------------
  def initialize(actor)
    off_h = (WLH + 32) * 2
    super(0, off_h, Graphics.width / 2 + 80, Graphics.height - off_h)
    @actor = actor
    refresh
    self.index = 0
  end
  #--------------------------------------------------------------------------
  # ○ 選択中のパラメータの Symbol を取得
  #--------------------------------------------------------------------------
  def parameter_symbol
    return @data[self.index]
  end
  #--------------------------------------------------------------------------
  # ● リフレッシュ
  #--------------------------------------------------------------------------
  def refresh
    @data = []
    gain_params = @actor.gain_parameter_list
    KGC::DistributeParameter::PARAMS.each { |param|
      next if gain_params[param] == nil
      @data << param
    }
    @item_max = @data.size + 1
    create_contents
    @item_max -= 1
    draw_caption
    @item_max.times { |i| draw_item(i, @actor.can_distribute?(@data[i])) }
  end
  #--------------------------------------------------------------------------
  # ● 1 ページに表示できる行数の取得
  #--------------------------------------------------------------------------
  def page_row_max
    return super - 1
  end
  #--------------------------------------------------------------------------
  # ● 項目を描画する矩形の取得
  #    index : 項目番号
  #--------------------------------------------------------------------------
  def item_rect(index)
    rect = super(index)
    rect.y += WLH
    return rect
  end
  #--------------------------------------------------------------------------
  # ○ 見出しの描画
  #--------------------------------------------------------------------------
  def draw_caption
    self.contents.font.color = system_color
  # This is shown at the top of the column that lists the stats.
    self.contents.draw_text(  4, 0, 96, WLH, KGC::DistributeParameter::AT_CAPTION)
    self.contents.draw_text(120, 0, 40, WLH, Vocab.rp, 2)
  # This is shown at the top of the column that lists the number of stat points
  #  you will gain from buying the next point of the parameter.
    self.contents.draw_text(170, 0, 60, WLH, KGC::DistributeParameter::RT_CAPTION, 2)
  # This is shown at the top of the column that lists the current and max
  #  points you have in each parameter.
    self.contents.draw_text(240, 0, 80, WLH, KGC::DistributeParameter::SP_CAPTION, 2)
    self.contents.font.color = normal_color
  end
  #--------------------------------------------------------------------------
  # ○ 項目の描画
  #    index  : 項目番号
  #    enabled : 有効フラグ
  #--------------------------------------------------------------------------
  def draw_item(index, enabled = true)
    rect = item_rect(index)
    self.contents.clear_rect(rect)
    item = @data[index]
    if item != nil
      draw_parameter(rect.x, rect.y, @data[index], enabled)
    end
  end
  #--------------------------------------------------------------------------
  # ○ 能力値の描画
  #    x      : 描画先 X 座標
  #    y      : 描画先 Y 座標
  #    type    : 能力値の種類
  #    enabled : 有効フラグ
  #--------------------------------------------------------------------------
  def draw_parameter(x, y, type, enabled)
    case type
    when :maxhp
      name  = Vocab.hp
    when :maxmp
      name  = Vocab.mp
    when :atk
      name  = Vocab.atk
    when :def
      name  = Vocab.def
    when :spi
      name  = Vocab.spi
      when :res
name = Vocab.res
    when :agi
      name  = Vocab.agi
    when :hit
      name  = Vocab.hit
    when :eva
      name  = Vocab.eva
    when :cri
      name  = Vocab.cri
    when :skill_speed
      name  = Vocab.skill_speed
    when :item_speed
      name  = Vocab.item_speed
    when :odds
      name  = Vocab.odds
    else
      return
    end

    self.contents.font.color = normal_color
    self.contents.font.color.alpha = enabled ? 255 : 128
    self.contents.draw_text(x + 4, y, 96, WLH, name)

    gain = @actor.gain_parameter_list[type]
    value = @actor.distribute_cost(type)
    self.contents.draw_text(x + 120, y, 40, WLH, value, 2)
    value = sprintf("%+d", @actor.distribute_gain(type))
    self.contents.draw_text(x + 190, y, 40, WLH, value, 2)
    value = sprintf("%3d/%3d", @actor.distributed_count(type), gain[2])
    self.contents.draw_text(x + 236, y, 80, WLH, value, 2)
    self.contents.font.color = normal_color
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# □ Window_DistributeParameterStatus
#------------------------------------------------------------------------------
#  振り分け画面で、アクターのステータスを表示するウィンドウです。
#==============================================================================

class Window_DistributeParameterStatus < Window_Base
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #    actor : アクター
  #--------------------------------------------------------------------------
  def initialize(actor)
    dx = Graphics.width / 2 + 80
    off_h = (WLH + 32) * 2
    super(dx, off_h, Graphics.width - dx, Graphics.height - off_h)
    @actor = actor
    refresh
  end
  #--------------------------------------------------------------------------
  # ● リフレッシュ
  #--------------------------------------------------------------------------
  def refresh
    original_height = self.height
    self.height = WLH * (existing_params.size + 1) + 32
    create_contents
    self.height = original_height

    self.contents.font.color = system_color
    # This allows you to change the text that appears on top of the right panel
    #  which contains current parameter changes.
    self.contents.draw_text(0, 0, width - 32, WLH, KGC::DistributeParameter::CS_CAPTION, 1)
    self.contents.font.color = normal_color
    dy = WLH
    existing_params.each { |param|
      draw_parameter(0, dy, param)
      dy += WLH
    }
  end
  #--------------------------------------------------------------------------
  # ○ 存在するパラメータの一覧
  #--------------------------------------------------------------------------
  def existing_params
    result = []
    gain_params = @actor.gain_parameter_list
    KGC::DistributeParameter::PARAMS.each { |param|
      next if gain_params[param] == nil
      result << param
    }
    return result
  end
  #--------------------------------------------------------------------------
  # ○ 能力値の描画
  #    x    : 描画先 X 座標
  #    y    : 描画先 Y 座標
  #    type : 能力値の種類
  #--------------------------------------------------------------------------
  def draw_parameter(x, y, type)
    case type
    when :maxhp
      name  = Vocab.hp
      value = @actor.maxhp
    when :maxmp
      name  = Vocab.mp
      value = @actor.maxmp
    when :atk
      name  = Vocab.atk
      value = @actor.atk
    when :def
      name  = Vocab.def
      value = @actor.def
    when :spi
      name  = Vocab.spi
      value = @actor.spi
      when :res
name = Vocab.res
value = @actor.res
    when :agi
      name  = Vocab.agi
      value = @actor.agi
    when :hit
      name  = Vocab.hit
      value = @actor.hit
    when :eva
      name  = Vocab.eva
      value = @actor.eva
    when :cri
      name  = Vocab.cri
      value = @actor.cri
    when :skill_speed
      name  = Vocab.skill_speed
      value = @actor.distributed_param(type)
    when :item_speed
      name  = Vocab.item_speed
      value = @actor.distributed_param(type)
    when :odds
      name  = Vocab.odds
      value = @actor.odds
    else
      return
    end
    draw_actor_distribute_gauge(@actor, type, x + 106, y, 48)
    self.contents.font.color = system_color
    self.contents.draw_text(x + 4, y, 96, WLH, name)
    self.contents.font.color = normal_color
    self.contents.draw_text(x + 106, y, 48, WLH, value, 2)
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Scene_Map
#==============================================================================

class Scene_Map < Scene_Base
  #--------------------------------------------------------------------------
  # ● 画面切り替えの実行
  #--------------------------------------------------------------------------
  alias update_scene_change_KGC_DistributeParameter update_scene_change
  def update_scene_change
    return if $game_player.moving?    # プレイヤーの移動中？

    if $game_temp.next_scene == :distribute_parameter
      call_distribute_parameter
      return
    end

    update_scene_change_KGC_DistributeParameter
  end
  #--------------------------------------------------------------------------
  # ○ パラメータ振り分け画面への切り替え
  #--------------------------------------------------------------------------
  def call_distribute_parameter
    $game_temp.next_scene = nil
    $scene = Scene_DistributeParameter.new(
      $game_temp.next_scene_actor_index,
      0,
      Scene_DistributeParameter::HOST_MAP)
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# ■ Scene_Menu
#==============================================================================

class Scene_Menu < Scene_Base
  if KGC::DistributeParameter::USE_MENU_DISTRIBUTE_PARAMETER_COMMAND
  #--------------------------------------------------------------------------
  # ● コマンドウィンドウの作成
  #--------------------------------------------------------------------------
  alias create_command_window_KGC_DistributeParameter create_command_window
  def create_command_window
    create_command_window_KGC_DistributeParameter

    return if $imported["CustomMenuCommand"]

    @__command_distribute_parameter_index =
      @command_window.add_command(Vocab.distribute_parameter)
    if @command_window.oy > 0
      @command_window.oy -= Window_Base::WLH
    end
    @command_window.index = @menu_index
  end
  end
  #--------------------------------------------------------------------------
  # ● コマンド選択の更新
  #--------------------------------------------------------------------------
  alias update_command_selection_KGC_DistributeParameter update_command_selection
  def update_command_selection
    call_distribute_parameter_flag = false
    if Input.trigger?(Input::C)
      case @command_window.index
      when @__command_distribute_parameter_index  # パラメータ振り分け
        call_distribute_parameter_flag = true
      end
    end

    # パラメータ振り分け画面に移行
    if call_distribute_parameter_flag
      if $game_party.members.size == 0
        Sound.play_buzzer
        return
      end
      Sound.play_decision
      start_actor_selection
      return
    end

    update_command_selection_KGC_DistributeParameter
  end
  #--------------------------------------------------------------------------
  # ● アクター選択の更新
  #--------------------------------------------------------------------------
  alias update_actor_selection_KGC_DistributeParameter update_actor_selection
  def update_actor_selection
    if Input.trigger?(Input::C)
      $game_party.last_actor_index = @status_window.index
      Sound.play_decision
      case @command_window.index
      when @__command_distribute_parameter_index  # パラメータ振り分け
        $scene = Scene_DistributeParameter.new(
          @status_window.index,
          @__command_distribute_parameter_index,
          Scene_DistributeParameter::HOST_MENU)
        return
      end
    end

    update_actor_selection_KGC_DistributeParameter
  end
end

#★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★☆★

#==============================================================================
# □ Scene_DistributeParameter
#------------------------------------------------------------------------------
#  パラメータ振り分け画面の処理を行うクラスです。
#==============================================================================

class Scene_DistributeParameter < Scene_Base
  #--------------------------------------------------------------------------
  # ○ 定数
  #--------------------------------------------------------------------------
  HOST_MENU  = 0  # 呼び出し元 : メニュー
  HOST_MAP    = 1  # 呼び出し元 : マップ
  #--------------------------------------------------------------------------
  # ● オブジェクト初期化
  #    actor_index : アクターインデックス
  #    menu_index  : コマンドのカーソル初期位置
  #    host_scene  : 呼び出し元 (0..メニュー  1..マップ)
  #--------------------------------------------------------------------------
  def initialize(actor_index = 0, menu_index = 0, host_scene = HOST_MENU)
    @actor_index = actor_index
    @menu_index = menu_index
    @host_scene = host_scene
  end
  #--------------------------------------------------------------------------
  # ● 開始処理
  #--------------------------------------------------------------------------
  def start
    super
    create_menu_background

    @actor = $game_party.members[@actor_index]
    create_windows
  end
  #--------------------------------------------------------------------------
  # ○ ウィンドウ作成
  #--------------------------------------------------------------------------
  def create_windows
    @help_window = Window_Help.new
    @help_window.set_text(KGC::DistributeParameter::DISTRIBUTE_SCENE_CAPTION)
    dy = @help_window.height
    @actor_window = Window_DistributeParameterActor.new(0, dy, @actor)
    @parameter_window = Window_DistributeParameterList.new(@actor)
    @status_window = Window_DistributeParameterStatus.new(@actor)
  end
  #--------------------------------------------------------------------------
  # ● 終了処理
  #--------------------------------------------------------------------------
  def terminate
    super
    dispose_menu_background
    @help_window.dispose
    @actor_window.dispose
    @parameter_window.dispose
    @status_window.dispose
  end
  #--------------------------------------------------------------------------
  # ○ 元の画面へ戻る
  #--------------------------------------------------------------------------
  def return_scene
    case @host_scene
    when HOST_MENU
      $scene = Scene_Menu.new(@menu_index)
    when HOST_MAP
      $scene = Scene_Map.new
    end
  end
  #--------------------------------------------------------------------------
  # ● フレーム更新
  #--------------------------------------------------------------------------
  def update
    super
    update_menu_background
    update_window
    if @parameter_window.active
      update_parameter_list
    end
  end
  #--------------------------------------------------------------------------
  # ○ ウィンドウ更新
  #--------------------------------------------------------------------------
  def update_window
    @help_window.update
    @actor_window.update
    @parameter_window.update
    @status_window.update
  end
  #--------------------------------------------------------------------------
  # ○ ウィンドウ再描画
  #--------------------------------------------------------------------------
  def refresh_window
    @actor_window.refresh
    @parameter_window.refresh
    @status_window.refresh
    Graphics.frame_reset
  end
  #--------------------------------------------------------------------------
  # ○ 次のアクターの画面に切り替え
  #--------------------------------------------------------------------------
  def next_actor
    @actor_index += 1
    @actor_index %= $game_party.members.size
    $scene = Scene_DistributeParameter.new(@actor_index,
      @menu_index, @host_scene)
  end
  #--------------------------------------------------------------------------
  # ○ 前のアクターの画面に切り替え
  #--------------------------------------------------------------------------
  def prev_actor
    @actor_index += $game_party.members.size - 1
    @actor_index %= $game_party.members.size
    $scene = Scene_DistributeParameter.new(@actor_index,
      @menu_index, @host_scene)
  end
  #--------------------------------------------------------------------------
  # ○ フレーム更新 (パラメータウィンドウがアクティブの場合)
  #--------------------------------------------------------------------------
  def update_parameter_list
    @status_window.oy = @parameter_window.oy

    if Input.trigger?(Input::B)
      Sound.play_cancel
      return_scene
    elsif input_growth?
      # 加算
      param = @parameter_window.parameter_symbol
      unless @actor.can_distribute?(param)
        Sound.play_buzzer
        return
      end
      Input.repeat?(Input::C) ? Sound.play_decision : Sound.play_cursor
      @actor.rp_growth_effect(param)
      refresh_window
    elsif input_reverse_growth?
      # 減算
      param = @parameter_window.parameter_symbol
      if @actor.distributed_count(param) == 0
        Sound.play_buzzer
        return
      end
      Input.repeat?(Input::A) ? Sound.play_decision : Sound.play_cursor
      @actor.rp_growth_effect(param, true)
      refresh_window
    elsif Input.trigger?(Input::R)
      Sound.play_cursor
      next_actor
    elsif Input.trigger?(Input::L)
      Sound.play_cursor
      prev_actor
    end
  end
  #--------------------------------------------------------------------------
  # ○ 加算入力
  #--------------------------------------------------------------------------
  def input_growth?
    if KGC::DistributeParameter::ENABLE_REVERSE_DISTRIBUTE
      return Input.repeat?(Input::C) || Input.repeat?(Input::RIGHT)
    else
      return Input.trigger?(Input::C)
    end
  end
  #--------------------------------------------------------------------------
  # ○ 減算入力
  #--------------------------------------------------------------------------
  def input_reverse_growth?
    if KGC::DistributeParameter::ENABLE_REVERSE_DISTRIBUTE
      return Input.repeat?(Input::A) || Input.repeat?(Input::LEFT)
    else
      return false
    end
  end
end

#==============================================================================
# ■ Scene_Status
#==============================================================================
# Added by Mr. Anonymous
#==============================================================================
class Scene_Status < Scene_Base
  #--------------------------------------------------------------------------
  # ● Update Actor
  #--------------------------------------------------------------------------
    alias update_KGC_DistributeParameter update
    def update
      if KGC::DistributeParameter::CALL_DISTPARAMKEY != nil &&
        Input.trigger?(KGC::DistributeParameter::CALL_DISTPARAMKEY)
        Sound.play_decision
        $scene = Scene_DistributeParameter.new(@actor_index)
      end
    update_KGC_DistributeParameter
  end
end

#==============================================================================
# ■ Scene_File
#==============================================================================

class Scene_File < Scene_Base
  #--------------------------------------------------------------------------
  # ● Read Saved Data
  #    file : 読み込み用ファイルオブジェクト (オープン済み)
  #--------------------------------------------------------------------------
  alias read_save_data_KGC_DistributeParameter read_save_data
  def read_save_data(file)
    read_save_data_KGC_DistributeParameter(file)

    KGC::Commands.check_distribution_values
    Graphics.frame_reset
  end
end